@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/tests/Section16_SwitchStatements/Rule_16_3_UnconditionalBreak.test.ts

@@ -3,7 +3,7 @@ import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestF
 import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
 
 const passingCode = 
-`void foo16_3_1( void )
+`static void foo16_3_1( void )
 {
     int x, a, b;
     switch ( x )
@@ -26,41 +26,68 @@ const passingCode =
         default:
             break;
     }
-}`;
+}
+`;
 
 const failingCode = 
-`void foo16_3_2( void )
-{
-    int x = 4, a, b, c;
+`static void foo16_3_2( void ) {
+    int x = 4, a_16_3, b_16_3, c_16_3;
     switch (x) {
         case 1:
-            a = 1;
+            a_16_3 = 1;
             break;
-        case 2:  // Missing break
-            b = 10;
+        case 2:  
+            b_16_3 = 10; // Missing break - violation of rule 16.3
         case 6: 
         case 3:
             x++;
             // comment1
             x--;
-            // comment2
+            // comment2 Missing break - violation of rule 16.3
         default:
-            c = 30;
+            c_16_3 = 30; // Missing break - violation of rule 16.3
+    }
+}
+`;
+
+const misraExample = `
+static void foo16_3_3( void ) {
+    int x = 4, a_16_3, b_16_3, c_16_3;
+    switch ( x )
+    {
+    case 0:
+        break;          /* Compliant - unconditional break */
+    case 1:            /* Compliant - empty fall through allows a group */
+    case 2:
+        break;    
+        /* Compliant*/
+    case 4:
+        a_16_3 = b_16_3;          /* Non-compliant - break omitted (violation of rule 16.3) */
+    case 5:
+        if (a_16_3 == b_16_3) {
+            ++a_16_3;
+            break;        /* Non-compliant - conditional break (violation of rule 16.3) */
+        }
+    default:
+        ;               /* Non-compliant - default must also have a break (violation of rule 16.3) */
     }
-}`;
+}
+`;
 
 const files: TestFile[] = [
     { name: "bad.c", code: failingCode },
-    { name: "good.c", code: passingCode }
+    { name: "good.c", code: passingCode },
+    { name: "misra_example.c", code: misraExample }
 ];
 
 describe("Rule 16.3", () => {
     registerSourceCode(files);
 
     it("should detect errors in bad.c", () => {
-        expect(countMISRAErrors()).toBe(3);
+        expect(countMISRAErrors()).toBe(6);
 
         expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(3);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "misra_example.c"}).first()!)).toBe(3);
         expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
     });
 

package/src/tests/Section16_SwitchStatements/Rule_16_4_SwitchHasDefault.test.ts

@@ -3,7 +3,7 @@ import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestF
 import Query from "@specs-feup/lara/api/weaver/Query.js";
 
 const passingCode = 
-`void foo16_4_1( void )
+`static void foo16_4_1( void )
 {
     int x;
     switch ( x )
@@ -29,14 +29,13 @@ const passingCode =
         case 2:
             break;
     }
-}`;
+}
+`;
 
 const failingCode1 = 
-`void foo16_4_3( void )
-{
+`static void foo16_4_3 (void) {
     int x;
-    switch ( x )
-    {
+    switch (x) { // violation of rule 16.4
         case 0:
             ++x;
             break;
@@ -45,15 +44,14 @@ const failingCode1 =
             x--;
             break;
     }
-}`;
+}
+`;
 
 // 4 erros: two of them are related to having boolean switch condition
 const failingCode2 = 
-`void foo16_4_4( void )
-{
+`static void foo16_4_4 (void) {
     int x, a = 14;
-    switch ( x == 4) /* Default will not be introduced, as it will be converted by the other rule */
-    {
+    switch ( x == 4) { /* Default will not be introduced, as it will be converted by the other rule */
         case 1:
             ++x;
             break;
@@ -77,7 +75,7 @@ const failingCode2 =
 
 // 4 errors: two of them are related to having less than two clauses
 const failingCode3 = 
-`void foo16_4_5( void )
+`static void foo16_4_5( void )
 {
     int x, a = 14;
     switch (x) { /* Default will not be introduced, as it will be converted by the other rule*/

package/src/tests/Section16_SwitchStatements/Rule_16_5_DefaultFirstOrLast.test.ts

@@ -3,7 +3,7 @@ import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestF
 import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
 
 const passingCode1 = 
-`void foo16_5_1( void )
+`static void foo16_5_1( void )
 {
     int x;
     switch ( x ) {
@@ -30,7 +30,7 @@ const passingCode1 =
 }`;
 
 const failingCode1 = 
-`void foo16_5_3( void )
+`static void foo16_5_3( void )
 {
     int x;
     switch ( x ) {
@@ -46,7 +46,7 @@ const failingCode1 =
 }`;
 
 const failingCode2 = 
-`void foo16_5_4( void )
+`static void foo16_5_4( void )
 {
     int x;
     switch ( x ) {
@@ -66,7 +66,7 @@ const failingCode2 =
 }`;
 
 const failingCode3 = 
-`void foo16_5_5( void )
+`static void foo16_5_5( void )
 {
     int x;
     switch ( x ) {
@@ -88,7 +88,7 @@ const failingCode3 =
 }`;
 
 const failingCode4 = 
-`void foo16_5_6( void )
+`static void foo16_5_6( void )
 {
     int x;
     switch ( x ) {

package/src/tests/Section16_SwitchStatements/Rule_16_6_SwitchMinTwoClauses.test.ts

@@ -3,7 +3,7 @@ import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestF
 import { FileJp, FunctionJp, If, Switch } from "@specs-feup/clava/api/Joinpoints.js";
 
 const passingCode = 
-`void foo16_6_1( void )
+`static void foo16_6_1( void )
 {
     int x, a, b;
 
@@ -28,7 +28,7 @@ const passingCode =
 }`;
 
 const failingCode1 = 
-`int foo16_6_2( void )
+`static int foo16_6_2( void )
 {
     int x = 1;
     switch ( x )
@@ -47,7 +47,7 @@ const failingCode1 =
 }`;
 
 const failingCode2 = 
-`int foo16_6_3( void )
+`static int foo16_6_3( void )
 {
     int x = 10, a, b;
 
@@ -65,7 +65,7 @@ const failingCode2 =
 
 // 2 erros: one is related to not having a default case
 const failingCode3 = 
-`int foo16_6_4( void )
+`static int foo16_6_4( void )
 {
     int x = 10, a, b;
 
@@ -81,7 +81,7 @@ const failingCode3 =
 }`;
 
 const failingCode4 = 
-`int foo16_6_5( void )
+`static int foo16_6_5( void )
 {
     int x = 10, a, b;
 

package/src/tests/Section16_SwitchStatements/Rule_16_7_NonBooleanSwitchCondition.test.ts

@@ -3,7 +3,7 @@ import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestF
 import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
 
 const passingCode = 
-`void foo16_7_1( int num )
+`static void foo16_7_1( int num )
 {
     switch (num) { 
         case 0:
@@ -22,10 +22,10 @@ const failingCode1 =
 `
 #include <stdbool.h>
 
-void foo16_6_2( int num )
+static void foo16_6_2( int num )
 {
     int a = 7;
-    switch (num % 3) { 
+    switch ((num % 3) == 0) { 
         case 0:
             a *= 2;
             break;
@@ -38,7 +38,7 @@ void foo16_6_2( int num )
     }
 }
     
-void foo16_6_3( bool flag )
+static void foo16_6_3( bool flag )
 {
     int a = 7;
     switch (flag) { 
@@ -59,7 +59,7 @@ const failingCode2 =
 `
 #include <stdbool.h>
 
-void foo16_6_4( bool flag )
+static void foo16_6_4( bool flag )
 {
     int a = 7, b = 10;
     switch (flag) { 

package/src/tests/Section17_Functions/Rule_17_3_ImplicitFunctions.test.ts

@@ -1,79 +1,107 @@
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
 import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
 import path from "path";
 import { fileURLToPath } from "url";
 
 const passingCode = `
-#include <stdio.h>
-int func() {
+
+extern double test_17_3_4();
+
+// Missing "static" keyword; Will have external decl after correction
+unsigned int foo_17_3() {
     return 0;
 }
 
-void test_17_3_1() {
-    printf("Result: %.2f ", func());
-}`;
+// Missing "static" keyword; Will have external decl after correction
+double test_17_3_1() {
+    return foo_17_3() + test_17_3_4();
+}
+`;
+
+const passingCode2 = `
+extern int foo_17_3();
+extern double test_17_3_1();
+
+double test_17_3_4() {
+    return foo_17_3() + test_17_3_1();
+}
+`;
 
 const failingCode = `
-void test_17_3_2() {
+static void test_17_3_2() {
     double a = 2.0, b = 3.0;
 
-    // Implicit call to pow(): math.h is missing
-    double res1 = pow(a, b); 
-    double res2 = pow(b, a);
+    // Implicit call to pow(): <math.h> is missing
+    double res1 = pow(a, b); // Violation of rule 17.3
+    double res2 = pow(b, a); // Violation of rule 17.3
 
-    // Implicit call to printf(): studio.h is missing
-    // Return value is not being used
-    printf("Results: %.2f %.2f ", res1, res2);
+    // Implicit call to toupper: <ctype.h> is missing
+    char lower1 = 'a';
+    char upper1 = toupper(lower1); // Violation of rule 17.3
     
-    // Implicit call to sin(): math.h is missing
+    // Implicit call to sin(): <math.h> is missing
     double angle = 3.14159265; 
-    double sin_val = sin(angle);
-
-    // Implicit call to printf(): studio.h is missing
-    // Return value is not being used
-    printf("Sin: %.2f ", sin_val);
+    double sin_val = sin(angle); // Violation of rule 17.3
 
-    // Implicit call to print(): studio.h will not solve this issue
-    // Return value is not being used
-    (void) print("End of program");
-
-}`;
+    // Implicit call to strlen(): <ctype.h> is missing
+    char lower2 = 'b';
+    char upper2 = toupper(lower2);  // Violation of rule 17.3
+}
+`;
 
 const failingCode2 = `
 #include <math.h>
 
-int func() {
+static unsigned int bar_17_3() {
     double a = 2.0, b = 3.0;
 
     double pow_result = pow(a, b); 
-    double sum = half(b) + pow_result;  // Implicit call: provided math.h does not solve
 
-    // Implicit call: provided stdio.h does not solve the issue
-    // Return value is not being used
-    println("Result: ", sum);
+    // Implicit call: <string.h> is missing
+    char lower1 = 'a';
+    char upper1 = toupper(lower1); // Violation of rule 17.3
 
     return 0;
-}`;
+}
+`;
+
+// Missing externs
+const failingCode3 = `
+static unsigned int test_17_3_3() {
+    int x = foo_17_3(); // Implicit call to foo_17_3() in good.c - violation of rule 17.3
+
+    (void) test_17_3_1(); // Implicit call with wrong params - violation of rule 17.3
+    return 0;
+}
+`;
 
 const files: TestFile[] = [
     { name: "bad1.c", code: failingCode },
     { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
     { name: "good.c", code: passingCode },
+    { name: "good2.c", code:passingCode2 }
 ];
 
-describe("Rule 17.4", () => {
-    registerSourceCode(files);
-
-    it("should detect errors", () => {
-        expect(countMISRAErrors()).toBe(12);
-    });
-
-    it("should correct errors", () => {
+describe("Rule 17.3", () => {
+    if (Clava.getStandard() !== "c90")  {
+            it("should skip tests for c99 and c11", () => {});
+    } else { 
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = path.dirname(__filename);
 
         const configFilename = "misra_config.json";
         const configFilePath = path.join(__dirname, configFilename);
 
-        expect(countErrorsAfterCorrection(configFilePath)).toBe(3);
-    });
-});
+        registerSourceCode(files, configFilePath);
+
+        it("should detect errors", () => {
+            expect(countMISRAErrors()).toBe(8);  
+            expect(countMISRAErrors("17.3")).toBe(8); 
+        });
+
+        it("should correct errors", () => {
+            expect(countErrorsAfterCorrection()).toBe(0);
+        });
+    }
+});

package/src/tests/Section17_Functions/Rule_17_3_ImplicitFunctions_MissingConfig.test.ts

@@ -0,0 +1,98 @@
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const passingCode = `
+#include <math.h>
+
+static unsigned int func() {
+    return 0;
+}
+
+static void test_17_3_1() {
+    double result = sqrt(func());
+}
+`;
+
+
+const failingCode = `
+static void test_17_3_2() {
+    double a = 2.0, b = 3.0;
+
+    // Implicit call to pow(): <math.h> is missing
+    double res1 = pow(a, b); 
+    double res2 = pow(b, a);
+
+    // Implicit call to strlen: <ctype.h> is missing
+    char lower1 = 'a';
+    char upper1 = toupper(lower1); 
+    
+    // Implicit call to sin(): <math.h> is missing
+    double angle = 3.14159265; 
+    double sin_val = sin(angle);
+
+    // Implicit call to strlen(): <ctype.h> is missing
+    char lower2 = 'b';
+    char upper2 = toupper(lower2); 
+
+    // Implicit call to toupper_transformation(): <ctype.h> is missing
+    char lower3 = 'c';
+    char upper3 = toupper_transformation(lower3); 
+
+}`;
+
+const failingCode2 = `
+#include <math.h>
+
+static unsigned int func2() {
+    double a = 2.0, b = 3.0;
+
+    double pow_result = pow(a, b); 
+    double sum = half(b) + pow_result;  // Implicit call to 'half': provided math.h does not solve
+
+    // Implicit call: <ctype.h> is missing
+    char lower1 = 'a';
+    char upper1 = toupper_transformation(lower1);
+
+    return 0;
+}`;
+
+// Missing externs
+const failingCode3 = `
+static unsigned int test_17_3_3() {
+    int x = func(); // Implicit call to func() in good.c
+
+    // Implicit call to func2() in bad2.c; Provided file in config does not include definition
+    int y = func2(); 
+
+    // Implicit call with wrong params
+    (void) test_17_3_1(1, 4);
+    return 0;
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
+    { name: "good.c", code: passingCode },
+];
+
+describe("Rule 17.3 (without config)", () => {
+    if (Clava.getStandard() !== "c90")  {
+        it("should skip tests for c99 and c11", () => {});
+    } else {
+        registerSourceCode(files);
+
+        it("should detect errors", () => {
+            expect(countMISRAErrors()).toBe(11);  
+            expect(countMISRAErrors("17.3")).toBe(11); 
+
+        });
+
+        it("should correct errors", () => {
+            expect(countErrorsAfterCorrection()).toBe(11);
+        });
+    }
+});

package/src/tests/Section17_Functions/Rule_17_3_ImplicitFunctions_ProblematicConfig.test.ts

@@ -0,0 +1,71 @@
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const passingCode = `
+#include <math.h>
+
+static unsigned int func() {
+    return 0;
+}
+
+void test_17_3_1() {
+    double result = sqrt(func());
+}
+`;
+
+const failingCode2 = `
+#include <math.h>
+
+static unsigned int func2() {
+    double a = 2.0, b = 3.0;
+
+    double pow_result = pow(a, b); 
+    double sum = half(b) + pow_result;  // Implicit call to 'half': provided math.h does not solve
+
+    // Implicit call: provided <ctype.h> does not solve
+    char lower1 = 'a';
+    char upper1 = toupper_transformation(lower1);
+
+    return 0;
+}
+`;
+
+// Missing externs
+const failingCode3 = `
+static unsigned int test_17_3_3() {
+    int x = func(); // Implicit call to func() in good.c but does not have external linkage
+
+    // Implicit call to func2() in bad2.c; Provided file in config does not include definition
+    int y = func2(); 
+
+    // Implicit call with wrong params
+    (void) test_17_3_1(1, 4);
+    return 0;
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
+    { name: "good.c", code: passingCode },
+];
+
+describe("Rule 17.3 (without config)", () => {
+    if (Clava.getStandard() !== "c90")  {
+        it("should skip tests for c99 and c11", () => {});
+    } else {
+        registerSourceCode(files);
+
+        it("should detect errors", () => {
+            expect(countMISRAErrors()).toBe(6);  
+            expect(countMISRAErrors("17.3")).toBe(5); 
+
+        });
+
+        it("should correct errors", () => {
+            expect(countErrorsAfterCorrection()).toBe(5);
+        });
+    }
+});