adlint 1.10.0 → 1.12.0

data/features/message_detection/W0735.feature

@@ -0,0 +1,322 @@
+Feature: W0735
+
+  W0735 detects that right side of logical expression is bitwise expression or
+  arithmetic expression.
+
+  Scenario: right side of `&&' operator is an arithmetic expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c)
+      {
+          int r;
+
+          r = a && (b + c); /* W0735 */
+          r = a && (b - c); /* W0735 */
+          r = a && (b * c); /* W0735 */
+          r = a && (b / c); /* W0735 */
+          r = a && (b % c); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0723 | 5    | 17     |
+      | W0723 | 6    | 17     |
+      | W0723 | 7    | 17     |
+      | W0093 | 8    | 17     |
+      | W0093 | 9    | 17     |
+      | W0104 | 1    | 22     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 11     |
+      | W0735 | 5    | 14     |
+      | W0088 | 6    | 11     |
+      | W0735 | 6    | 14     |
+      | W0088 | 7    | 11     |
+      | W0735 | 7    | 14     |
+      | W0088 | 8    | 11     |
+      | W0735 | 8    | 14     |
+      | W0088 | 9    | 11     |
+      | W0735 | 9    | 14     |
+      | W0628 | 1    | 13     |
+
+  Scenario: right side of `&&' operator is an arithmetic expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c, int d)
+      {
+          int r;
+
+          r = (a == b) && (c + d); /* W0735 */
+          r = (a = b) && (c - d); /* W0735 */
+          r = (a && b) && (c * d); /* W0735 */
+          r = (a < b) && (c / d); /* W0735 */
+          r = (a != b) && (c % d); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0723 | 5    | 24     |
+      | W0723 | 6    | 23     |
+      | W0723 | 7    | 24     |
+      | W0093 | 8    | 23     |
+      | W0093 | 9    | 24     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0104 | 1    | 43     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 18     |
+      | W0735 | 5    | 21     |
+      | W0088 | 6    | 17     |
+      | W0735 | 6    | 20     |
+      | W0088 | 7    | 18     |
+      | W0735 | 7    | 21     |
+      | W0088 | 8    | 17     |
+      | W0735 | 8    | 20     |
+      | W0088 | 9    | 18     |
+      | W0735 | 9    | 21     |
+      | W0108 | 6    | 12     |
+      | W0628 | 1    | 13     |
+
+  Scenario: right side of `||' operator is an arithmetic expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c)
+      {
+          int r;
+
+          r = a || (b + c); /* W0735 */
+          r = a || (b - c); /* W0735 */
+          r = a || (b * c); /* W0735 */
+          r = a || (b / c); /* W0735 */
+          r = a || (b % c); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0723 | 5    | 17     |
+      | W0723 | 6    | 17     |
+      | W0723 | 7    | 17     |
+      | W0093 | 8    | 17     |
+      | W0093 | 9    | 17     |
+      | W0104 | 1    | 22     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 11     |
+      | W0735 | 5    | 14     |
+      | W0088 | 6    | 11     |
+      | W0735 | 6    | 14     |
+      | W0088 | 7    | 11     |
+      | W0735 | 7    | 14     |
+      | W0088 | 8    | 11     |
+      | W0735 | 8    | 14     |
+      | W0088 | 9    | 11     |
+      | W0735 | 9    | 14     |
+      | W0628 | 1    | 13     |
+
+  Scenario: right side of `||' operator is an arithmetic expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c, int d)
+      {
+          int r;
+
+          r = (a == b) || (c + d); /* W0735 */
+          r = (a = b) || (c - d); /* W0735 */
+          r = (a || b) || (c * d); /* W0735 */
+          r = (a < b) || (c / d); /* W0735 */
+          r = (a != b) || (c % d); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0723 | 5    | 24     |
+      | W0723 | 6    | 23     |
+      | W0723 | 7    | 24     |
+      | W0093 | 8    | 23     |
+      | W0093 | 9    | 24     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0104 | 1    | 43     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 18     |
+      | W0735 | 5    | 21     |
+      | W0088 | 6    | 17     |
+      | W0735 | 6    | 20     |
+      | W0088 | 7    | 18     |
+      | W0735 | 7    | 21     |
+      | W0088 | 8    | 17     |
+      | W0735 | 8    | 20     |
+      | W0088 | 9    | 18     |
+      | W0735 | 9    | 21     |
+      | W0108 | 6    | 12     |
+      | W0628 | 1    | 13     |
+
+  Scenario: right side of `&&' operator is a bitwise expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c)
+      {
+          int r;
+
+          r = a && (b << c); /* W0735 */
+          r = a && (b >> c); /* W0735 */
+          r = a && (b & c); /* W0735 */
+          r = a && (b ^ c); /* W0735 */
+          r = a && (b | c); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0570 | 5    | 17     |
+      | W0572 | 5    | 17     |
+      | W0571 | 6    | 17     |
+      | W0572 | 6    | 17     |
+      | W0572 | 7    | 17     |
+      | W0572 | 8    | 17     |
+      | W0572 | 9    | 17     |
+      | W0104 | 1    | 22     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 11     |
+      | W0735 | 5    | 14     |
+      | W0088 | 6    | 11     |
+      | W0735 | 6    | 14     |
+      | W0088 | 7    | 11     |
+      | W0735 | 7    | 14     |
+      | W0088 | 8    | 11     |
+      | W0735 | 8    | 14     |
+      | W0088 | 9    | 11     |
+      | W0735 | 9    | 14     |
+      | W0628 | 1    | 13     |
+
+  Scenario: right side of `||' operator is a bitwise expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c)
+      {
+          int r;
+
+          r = a || (b << c); /* W0735 */
+          r = a || (b >> c); /* W0735 */
+          r = a || (b & c); /* W0735 */
+          r = a || (b ^ c); /* W0735 */
+          r = a || (b | c); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0570 | 5    | 17     |
+      | W0572 | 5    | 17     |
+      | W0571 | 6    | 17     |
+      | W0572 | 6    | 17     |
+      | W0572 | 7    | 17     |
+      | W0572 | 8    | 17     |
+      | W0572 | 9    | 17     |
+      | W0104 | 1    | 22     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 11     |
+      | W0735 | 5    | 14     |
+      | W0088 | 6    | 11     |
+      | W0735 | 6    | 14     |
+      | W0088 | 7    | 11     |
+      | W0735 | 7    | 14     |
+      | W0088 | 8    | 11     |
+      | W0735 | 8    | 14     |
+      | W0088 | 9    | 11     |
+      | W0735 | 9    | 14     |
+      | W0628 | 1    | 13     |
+
+  Scenario: right side of `&&' operator is a bitwise expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c, int d)
+      {
+          int r;
+
+          r = (a == b) && (c << d); /* W0735 */
+          r = (a = b) && (c >> d); /* W0735 */
+          r = (a && b) && (c & d); /* W0735 */
+          r = (a < b) && (c ^ d); /* W0735 */
+          r = (a != b) && (c | d); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0570 | 5    | 24     |
+      | W0572 | 5    | 24     |
+      | W0571 | 6    | 23     |
+      | W0572 | 6    | 23     |
+      | W0572 | 7    | 24     |
+      | W0572 | 8    | 23     |
+      | W0572 | 9    | 24     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0104 | 1    | 43     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 18     |
+      | W0735 | 5    | 21     |
+      | W0088 | 6    | 17     |
+      | W0735 | 6    | 20     |
+      | W0088 | 7    | 18     |
+      | W0735 | 7    | 21     |
+      | W0088 | 8    | 17     |
+      | W0735 | 8    | 20     |
+      | W0088 | 9    | 18     |
+      | W0735 | 9    | 21     |
+      | W0108 | 6    | 12     |
+      | W0628 | 1    | 13     |
+
+  Scenario: right side of `||' operator is a bitwise expression
+    Given a target source named "W0735.c" with:
+      """
+      static void func(int a, int b, int c, int d)
+      {
+          int r;
+
+          r = (a == b) || (c << d); /* W0735 */
+          r = (a = b) || (c >> d); /* W0735 */
+          r = (a && b) || (c & d); /* W0735 */
+          r = (a < b) || (c ^ d); /* W0735 */
+          r = (a != b) || (c | d); /* W0735 */
+      }
+      """
+    When I successfully run `adlint W0735.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0570 | 5    | 24     |
+      | W0572 | 5    | 24     |
+      | W0571 | 6    | 23     |
+      | W0572 | 6    | 23     |
+      | W0572 | 7    | 24     |
+      | W0572 | 8    | 23     |
+      | W0572 | 9    | 24     |
+      | W0104 | 1    | 29     |
+      | W0104 | 1    | 36     |
+      | W0104 | 1    | 43     |
+      | W0629 | 1    | 13     |
+      | W0088 | 5    | 18     |
+      | W0735 | 5    | 21     |
+      | W0088 | 6    | 17     |
+      | W0735 | 6    | 20     |
+      | W0088 | 7    | 18     |
+      | W0735 | 7    | 21     |
+      | W0088 | 8    | 17     |
+      | W0735 | 8    | 20     |
+      | W0088 | 9    | 18     |
+      | W0735 | 9    | 21     |
+      | W0108 | 6    | 12     |
+      | W0628 | 1    | 13     |
+
+# vim:ts=2:sw=2:sts=2:et:

data/features/message_detection/W1052.feature

@@ -0,0 +1,66 @@
+Feature: W1052
+
+  W1052 detects that an arithmetic operation of unsigned values may be
+  overflow.
+
+  Scenario: multiplication of two arbitrary `unsigned char' values
+    Given a target source named "W1052.c" with:
+      """
+      static unsigned int foo(unsigned char a, unsigned char b)
+      {
+          return a * b; /* W1052 should not be output */
+      }
+      """
+    When I successfully run `adlint W1052.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0123 | 3    | 12     |
+      | W0246 | 3    | 12     |
+      | W0123 | 3    | 16     |
+      | W0246 | 3    | 16     |
+      | W0167 | 3    | 14     |
+      | W0303 | 3    | 5      |
+      | W0104 | 1    | 39     |
+      | W0104 | 1    | 56     |
+      | W0629 | 1    | 21     |
+      | W0628 | 1    | 21     |
+
+  Scenario: multiplication of two arbitrary `unsigned short' values
+    Given a target source named "W1052.c" with:
+      """
+      static unsigned int foo(unsigned short a, unsigned short b)
+      {
+          return a * b; /* W1052 */
+      }
+      """
+    When I successfully run `adlint W1052.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0248 | 3    | 12     |
+      | W0248 | 3    | 16     |
+      | W1052 | 3    | 14     |
+      | W0167 | 3    | 14     |
+      | W0303 | 3    | 5      |
+      | W0104 | 1    | 40     |
+      | W0104 | 1    | 58     |
+      | W0629 | 1    | 21     |
+      | W0628 | 1    | 21     |
+
+  Scenario: multiplication of two arbitrary `unsigned int' values
+    Given a target source named "W1052.c" with:
+      """
+      static unsigned int foo(unsigned int a, unsigned int b)
+      {
+          return a * b; /* W1052 */
+      }
+      """
+    When I successfully run `adlint W1052.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W1052 | 3    | 14     |
+      | W0104 | 1    | 38     |
+      | W0104 | 1    | 54     |
+      | W0629 | 1    | 21     |
+      | W0628 | 1    | 21     |
+
+# vim:ts=2:sw=2:sts=2:et:

data/features/message_detection/W9001.feature

@@ -0,0 +1,33 @@
+Feature: W9001
+
+  W9001 detects that the control never reach to a statement.
+
+  Scenario: indefinitive controlling variable narrowing
+    Given a target source named "W9001.c" with:
+      """
+      static void bar(int);
+
+      int main(void)
+      {
+          int i;
+          int j;
+
+          for (i = 0; i < 10; i++) {
+              for (j = 0; j < 10; j++) {
+                  if (i == j) {
+                      bar(1);
+                  }
+                  else {
+                      bar(2); /* W9001 should not be output */
+                  }
+              }
+          }
+
+          return 0;
+      }
+      """
+    When I successfully run `adlint W9001.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+
+# vim:ts=2:sw=2:sts=2:et:

data/features/message_detection/W9003.feature

@@ -0,0 +1,131 @@
+Feature: W9003
+
+  W9003 detects that an object is implicitly converted into a new object of
+  the different type.
+
+  Scenario: passing an enum variable whose type differs from one of the
+            corresponding enum parameter
+    Given a target source named "W9003.c" with:
+      """
+      enum Color { RED, BLUE, GREEN };
+      enum Fruit { APPLE, BANANA, ORANGE };
+
+      extern void foo(enum Color);
+
+      static void bar(void)
+      {
+          foo(ORANGE); /* W9003 */
+      }
+      """
+    When I successfully run `adlint W9003.c` on noarch
+    Then the output should match with /8:.*:W9003/
+    And the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 4    | 13     |
+      | W9003 | 8    | 9      |
+      | W0728 | 8    | 9      |
+      | W0629 | 6    | 13     |
+      | W0628 | 6    | 13     |
+
+  Scenario: passing an enum argument as an `int' parameter
+    Given a target source named "W9003.c" with:
+      """
+      enum Color { RED, BLUE, GREEN };
+
+      extern void foo(int);
+
+      static void bar(void)
+      {
+          foo(RED); /* W9003 */
+      }
+      """
+    When I successfully run `adlint W9003.c` on noarch
+    Then the output should match with /7:.*:W9003/
+    And the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 3    | 13     |
+      | W9003 | 7    | 9      |
+      | W1059 | 7    | 9      |
+      | W0629 | 5    | 13     |
+      | W0628 | 5    | 13     |
+
+  Scenario: passing an `int' argument as an enum parameter
+    Given a target source named "W9003.c" with:
+      """
+      enum Color { RED, BLUE, GREEN };
+
+      extern void foo(enum Color);
+
+      static void bar(void)
+      {
+          foo(0); /* W9003 */
+      }
+      """
+    When I successfully run `adlint W9003.c` on noarch
+    Then the output should match with /7:.*:W9003/
+    And the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 3    | 13     |
+      | W9003 | 7    | 9      |
+      | W1053 | 7    | 9      |
+      | W0629 | 5    | 13     |
+      | W0628 | 5    | 13     |
+
+  Scenario: initializing an `int' variable with an enumerator
+    Given a target source named "W9003.c" with:
+      """
+      enum Color { RED, BLUE, GREEN };
+      int i = RED; /* W9003 */
+      """
+    When I successfully run `adlint W9003.c` on noarch
+    Then the output should match with /2:.*:W9003/
+    And the output should exactly match with:
+      | mesg  | line | column |
+      | W9003 | 2    | 9      |
+      | W0117 | 2    | 5      |
+
+  Scenario: initializing an enum variable with an `int' value
+    Given a target source named "W9003.c" with:
+      """
+      enum Color { RED, BLUE, GREEN };
+      enum Color c = 1; /* W9003 */
+      """
+    When I successfully run `adlint W9003.c` on noarch
+    Then the output should match with /2:.*:W9003/
+    And the output should exactly match with:
+      | mesg  | line | column |
+      | W9003 | 2    | 16     |
+      | W0117 | 2    | 12     |
+
+  Scenario: arithmetic expression with an `int' variable and an enum variable
+    Given a target source named "W9003.c" with:
+      """
+      enum Color { RED, BLUE, GREEN };
+
+      static int foo(enum Color c)
+      {
+          if (c == RED || c == BLUE || c == GREEN) {
+              return c + 10; /* W9003 */
+          }
+          else {
+              return 0;
+          }
+      }
+      """
+    When I successfully run `adlint W9003.c` on noarch
+    Then the output should match with /6:.*:W9003/
+    And the output should exactly match with:
+      | mesg  | line | column |
+      | W0727 | 6    | 20     |
+      | W9003 | 6    | 20     |
+      | W9003 | 6    | 18     |
+      | W1060 | 6    | 18     |
+      | W0104 | 3    | 27     |
+      | W0629 | 3    | 12     |
+      | W0490 | 5    | 9      |
+      | W0497 | 5    | 9      |
+      | W0497 | 5    | 9      |
+      | W0502 | 5    | 9      |
+      | W0628 | 3    | 12     |
+
+# vim:ts=2:sw=2:sts=2:et: