Add more test cases

jeongsoolee09 · jeongsoolee09 · commit 9fa5cb207fd9 · 2025-07-10T14:25:31.000-07:00
- 1. Assigning a char to another char
  - 1-1. Assigning a char to a char variable
  - 1-2. Assigning a char to a char member
  - 1-3. Assigning a char to a char through a pointer

- 2. Passing a char argument to a char parameter
  - 2-1. Passing char argument to a char parameter of a regular function
  - 2-2. Passing char argument to a char parameter through a template
  - 2-3. Passing a char argument to a char parameter through a template
diff --git a/cpp/autosar/test/rules/M5-0-12/test.cpp b/cpp/autosar/test/rules/M5-0-12/test.cpp
@@ -1,16 +1,359 @@
 #include <cstdint>
 
-void f1() {
-  unsigned char a1 = 'c'; // NON_COMPLIANT
-  unsigned char a2 = 10;
-  signed char a3 = 'c'; // NON_COMPLIANT
-  signed char a4 = 10;
+template <typename T, T y> class C1 {
+public:
+  C1() : x(y) {}
 
-  std::int8_t a5 = 'c'; // NON_COMPLIANT
-  std::int8_t a6 = 10;
+private:
+  unsigned char x;
+};
 
-  std::uint8_t a7 = 'c'; // NON_COMPLIANT
-  std::uint8_t a8 = 10;
+template <typename T, T y> class C2 {
+public:
+  C2() : x(y) {}
 
-  char a9 = 'c';
+private:
+  signed char x;
+};
+
+template <typename T, T y> class C3 {
+public:
+  C3() : x(y) {}
+
+private:
+  unsigned char x;
+};
+
+template <typename T, T y> class C4 {
+public:
+  C4() : x(y) {}
+
+private:
+  signed char x;
+};
+
+/* Twin templates for std::uint8_t and std::int8_t */
+template <typename T, T y> class C9 {
+public:
+  C9() : x(y) {}
+
+private:
+  std::uint8_t x;
+};
+
+template <typename T, T y> class C10 {
+public:
+  C10() : x(y) {}
+
+private:
+  std::int8_t x;
+};
+
+template <typename T, T y> class C11 {
+public:
+  C11() : x(y) {}
+
+private:
+  std::uint8_t x;
+};
+
+template <typename T, T y> class C12 {
+public:
+  C12() : x(y) {}
+
+private:
+  std::int8_t x;
+};
+
+void f1(unsigned char x) {}
+void f2(signed char x) {}
+void f3(unsigned char x) {}
+void f4(signed char x) {}
+
+/* Twin functions for std::uint8_t and std::int8_t */
+void f9(std::uint8_t x) {}
+void f10(std::int8_t x) {}
+void f11(std::uint8_t x) {}
+void f12(std::int8_t x) {}
+
+template <typename T> void f5(T x) { unsigned char y = x; }
+template <typename T> void f6(T x) { signed char y = x; }
+template <typename T> void f7(T x) { signed char y = x; }
+template <typename T> void f8(T x) { signed char y = x; }
+
+/* Twin template functions for std::uint8_t and std::int8_t */
+template <typename T> void f13(T x) { std::uint8_t y = x; }
+template <typename T> void f14(T x) { std::int8_t y = x; }
+template <typename T> void f15(T x) { std::int8_t y = x; }
+template <typename T> void f16(T x) { std::int8_t y = x; }
+
+template <typename T> class C5 {
+public:
+  C5(T y) : x(y) {}
+
+private:
+  unsigned char x;
+};
+
+template <typename T> class C6 {
+public:
+  C6(T y) : x(y) {}
+
+private:
+  signed char x;
+};
+
+template <typename T> class C7 {
+public:
+  C7(T y) : x(y) {}
+
+private:
+  signed char x;
+};
+
+template <typename T> class C8 {
+public:
+  C8(T y) : x(y) {}
+
+private:
+  signed char x;
+};
+
+/* Twin template classes for std::uint8_t and std::int8_t */
+template <typename T> class C13 {
+public:
+  C13(T y) : x(y) {}
+
+private:
+  std::uint8_t x;
+};
+
+template <typename T> class C14 {
+public:
+  C14(T y) : x(y) {}
+
+private:
+  std::int8_t x;
+};
+
+template <typename T> class C15 {
+public:
+  C15(T y) : x(y) {}
+
+private:
+  std::int8_t x;
+};
+
+template <typename T> class C16 {
+public:
+  C16(T y) : x(y) {}
+
+private:
+  std::int8_t x;
+};
+
+int main() {
+
+  /* ========== 1. Assigning a char to another char ========== */
+
+  /* ===== 1-1. Assigning a char to a char variable ===== */
+
+  unsigned char x1 = 1;
+  unsigned char y1 =
+      x1; // COMPLIANT: unsigned char assigned to an unsigned char
+
+  signed char x2 = 1;
+  signed char y2 = x2; // COMPLIANT: signed char assigned to a signed char
+
+  char x3 = 'x';
+  unsigned char y3 = x3; // NON-COMPLIANT: plain char assigned to a unsigned char
+
+  char x4 = 'x';
+  signed char y4 = x4; // NON-COMPLIANT: plain char assigned to a signed char
+
+  /* Twin cases with std::uint8_t and std::int8_t */
+  std::uint8_t x5 = 1;
+  std::uint8_t y5 =
+      x5; // COMPLIANT: std::uint8_t assigned to a std::uint8_t
+
+  std::int8_t x6 = 1;
+  std::int8_t y6 = x6; // COMPLIANT: std::int8_t assigned to a std::int8_t
+
+  char x7 = 'x';
+  std::uint8_t y7 = x7; // NON-COMPLIANT: plain char assigned to a std::uint8_t
+
+  char x8 = 'x';
+  std::int8_t y8 = x8; // NON-COMPLIANT: plain char assigned to a std::int8_t
+
+  /* ===== 1-2. Assigning a char to a char member ===== */
+
+  C1<unsigned char, 1> c1; // COMPLIANT: unsigned char arg passed to an unsigned
+                           // char member through a template
+
+  C2<signed char, 1> c2; // COMPLIANT: signed char arg passed to a signed char
+                         // member through a template
+
+  C3<char, 'x'> c3; // NON-COMPLIANT: plain char arg passed to a unsigned char
+                    // member through a template
+
+  C4<char, 'x'> c4; // NON-COMPLIANT: plain char arg passed to a signed char
+                    // member through a template
+
+  /* Twin cases with std::uint8_t and std::int8_t */
+  C9<std::uint8_t, 1> c9; // COMPLIANT: std::uint8_t arg passed to a std::uint8_t
+                          // member through a template
+
+  C10<std::int8_t, 1> c10; // COMPLIANT: std::int8_t arg passed to a std::int8_t
+                           // member through a template
+
+  C11<char, 'x'> c11; // NON-COMPLIANT: plain char arg passed to a std::uint8_t
+                      // member through a template
+
+  C12<char, 'x'> c12; // NON-COMPLIANT: plain char arg passed to a std::int8_t
+                      // member through a template
+
+  /* ========== 1-3. Assigning a char to a char through a pointer ========== */
+
+  unsigned char x9 = 1;
+  unsigned char *y9 = &x9;
+  signed char z1 =
+      *y9; // COMPLIANT: unsigned char assigned to a *&unsigned char
+
+  unsigned char x10 = 1;
+  unsigned char *y10 = &x10;
+  signed char z2 = *y10; // COMPLIANT: signed char assigned to an *&signed char
+
+  char x11 = 1;
+  char *y11 = &x11;
+  unsigned char z3 =
+      *y11; // NON-COMPLIANT: plain char assigned to an *&unsigned char
+
+  char x12 = 1;
+  char *y12 = &x12;
+  signed char z4 =
+      *y12; // NON-COMPLIANT: plain char assigned to an *&signed char
+
+  /* Twin cases with std::uint8_t and std::int8_t */
+  std::uint8_t x13 = 1;
+  std::uint8_t *y13 = &x13;
+  std::int8_t z5 =
+      *y13; // COMPLIANT: std::uint8_t assigned to a *&std::uint8_t
+
+  std::uint8_t x14 = 1;
+  std::uint8_t *y14 = &x14;
+  std::int8_t z6 = *y14; // COMPLIANT: std::int8_t assigned to an *&std::int8_t
+
+  char x15 = 1;
+  char *y15 = &x15;
+  std::uint8_t z7 =
+      *y15; // NON-COMPLIANT: plain char assigned to an *&std::uint8_t
+
+  char x16 = 1;
+  char *y16 = &x16;
+  std::int8_t z8 =
+      *y16; // NON-COMPLIANT: plain char assigned to an *&std::int8_t
+
+  /* ========== 2. Passing a char argument to a char parameter ========== */
+
+  /* ===== 2-1. Passing char argument to a char parameter of a regular function
+   * ===== */
+
+  unsigned char a1 = 1;
+  f1(a1); // COMPLIANT: unsigned char arg passed to an unsigned char parameter
+
+  signed char a2 = 1;
+  f2(a2); // COMPLIANT: signed char arg passed to a signed char parameter
+
+  char a3 = 'a';
+  f3(a3); // NON-COMPLIANT: plain char arg passed to a unsigned char parameter
+
+  char a4 = 'a';
+  f4(a4); // NON-COMPLIANT: plain char arg passed to a signed char parameter
+
+  /* Twin cases with std::uint8_t and std::int8_t */
+  std::uint8_t a5 = 1;
+  f9(a5); // COMPLIANT: std::uint8_t arg passed to a std::uint8_t parameter
+
+  std::int8_t a6 = 1;
+  f10(a6); // COMPLIANT: std::int8_t arg passed to a std::int8_t parameter
+
+  char a7 = 'a';
+  f11(a7); // NON-COMPLIANT: plain char arg passed to a std::uint8_t parameter
+
+  char a8 = 'a';
+  f12(a8); // NON-COMPLIANT: plain char arg passed to a std::int8_t parameter
+
+  /* ===== 2-2. Passing char argument to a char parameter through a template
+   * ===== */
+
+  unsigned char a9 = 'a';
+  f5(a9); // COMPLIANT: unsigned char arg passed to an unsigned char parameter
+          // through a template
+
+  signed char a10 = 'a';
+  f6(a10); // COMPLIANT: signed char arg passed to a signed char parameter
+           // through a template
+
+  char a11 = 'a';
+  f7(a11); // NON-COMPLIANT: plain char arg passed to a unsigned char parameter
+           // through a template
+
+  char a12 = 'a';
+  f8(a12); // COMPLIANT: plain char arg passed to a signed char parameter through
+           // a template
+
+  /* Twin cases with std::uint8_t and std::int8_t */
+  std::uint8_t a13 = 'a';
+  f13(a13); // COMPLIANT: std::uint8_t arg passed to a std::uint8_t parameter
+            // through a template
+
+  std::int8_t a14 = 'a';
+  f14(a14); // COMPLIANT: std::int8_t arg passed to a std::int8_t parameter
+            // through a template
+
+  char a15 = 'a';
+  f15(a15); // NON-COMPLIANT: plain char arg passed to a std::uint8_t parameter
+            // through a template
+
+  char a16 = 'a';
+  f16(a16); // COMPLIANT: plain char arg passed to a std::int8_t parameter through
+            // a template
+
+  /* ========== 2-3. Passing a char argument to a char parameter through a
+   * template ========== */
+
+  unsigned char a17 = 1;
+  C5<unsigned char> c5(
+      a17); // COMPLIANT: unsigned char arg passed to an unsigned char parameter
+            // of a constructor through a template
+
+  signed char a18 = 1;
+  C6<signed char> c6(a18); // COMPLIANT: signed char arg passed to an signed
+                           // char parameter of a constructor through a template
+
+  char a19 = 'a';
+  C7<char> c7(a19); // NON-COMPLIANT: plain char arg passed to an unsigned char
+                    // parameter of a constructor through a template
+
+  char a20 = 'a';
+  C8<char> c8(a20); // NON-COMPLIANT: plain char arg passed to an signed char
+                    // parameter of a constructor through a template
+
+  /* Twin cases with std::uint8_t and std::int8_t */
+  std::uint8_t a21 = 1;
+  C13<std::uint8_t> c13(
+      a21); // COMPLIANT: std::uint8_t arg passed to a std::uint8_t parameter
+            // of a constructor through a template
+
+  std::int8_t a22 = 1;
+  C14<std::int8_t> c14(a22); // COMPLIANT: std::int8_t arg passed to a std::int8_t
+                             // parameter of a constructor through a template
+
+  char a23 = 'a';
+  C15<char> c15(a23); // NON-COMPLIANT: plain char arg passed to a std::uint8_t
+                      // parameter of a constructor through a template
+
+  char a24 = 'a';
+  C16<char> c16(a24); // NON-COMPLIANT: plain char arg passed to a std::int8_t
+                      // parameter of a constructor through a template
 }
