@specs-feup/clava-misra 1.0.0 → 1.0.2

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

@@ -0,0 +1,70 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
+
+const passingCode = 
+`void foo16_3_1( void )
+{
+    int x, a, b;
+    switch ( x )
+    {
+        case 0:
+            break; 
+        case 1:
+        case 2:
+            break; 
+        case 4:
+            a = b;
+            break;
+        case 5:
+            if ( a == b )
+            {
+                ++a;
+                break;
+            }
+            break;
+        default:
+            break;
+    }
+}`;
+
+const failingCode = 
+`void foo16_3_2( void )
+{
+    int x = 4, a, b, c;
+    switch (x) {
+        case 1:
+            a = 1;
+            break;
+        case 2:  // Missing break
+            b = 10;
+        case 6: 
+        case 3:
+            x++;
+            // comment1
+            x--;
+            // comment2
+        default:
+            c = 30;
+    }
+}`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 16.3", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(3);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(3);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

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

@@ -0,0 +1,128 @@
+import { FileJp, If, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+
+const passingCode = 
+`void foo16_4_1( void )
+{
+    int x;
+    switch ( x )
+    {
+        case 0:
+            ++x;
+            break;
+        case 1:
+        case 2:
+            break;
+        default:
+            break;
+    }
+
+    switch ( x )
+    {
+        default:
+            break;
+        case 0:
+            ++x;
+            break;
+        case 1:
+        case 2:
+            break;
+    }
+}`;
+
+const failingCode1 = 
+`void foo16_4_3( void )
+{
+    int x;
+    switch ( x )
+    {
+        case 0:
+            ++x;
+            break;
+        case 1:
+        case 2:
+            x--;
+            break;
+    }
+}`;
+
+// 4 erros: two of them are related to having boolean switch condition
+const failingCode2 = 
+`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 */
+    {
+        case 1:
+            ++x;
+            break;
+        case 0:
+            break;
+    }
+
+    switch ( x == 4)
+    {
+        case 0:
+            ++x;
+            if (a > 4) {
+                x = 7;
+                break;
+            }
+            break;
+        case 1:
+            break;
+    }
+}`;
+
+// 4 errors: two of them are related to having less than two clauses
+const failingCode3 = 
+`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*/
+        case 1:
+            ++x;
+            break;
+    }
+
+     switch ( x ) {
+        case 0:
+            ++x;
+            if (a > 4) {
+                x = 7;
+                break;
+            }
+            break;
+    }
+}`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode1 },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
+    { name: "good.c", code: passingCode },
+];
+
+describe("Rule 16.4", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(9);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad1.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad2.c"}).first()!)).toBe(4);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad3.c"}).first()!)).toBe(4);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(1);
+
+        const bad2File = Query.search(FileJp, {name: "bad2.c"}).first()!;
+        expect(Query.searchFrom(bad2File, Switch).get().length).toBe(1);
+
+        const bad3File = Query.search(FileJp, {name: "bad3.c"}).first()!;
+        expect(Query.searchFrom(bad3File, Switch).get().length).toBe(1);
+    });
+});

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

@@ -0,0 +1,132 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
+
+const passingCode1 = 
+`void foo16_5_1( void )
+{
+    int x;
+    switch ( x ) {
+        case 0:
+            ++x;
+            break;
+        case 1:
+        case 2:
+            break;
+        default:
+            break;
+    }
+
+    switch ( x ) {
+        default:
+            break;
+        case 0:
+            ++x;
+            break;
+        case 1:
+        case 2:
+            break;
+    }
+}`;
+
+const failingCode1 = 
+`void foo16_5_3( void )
+{
+    int x;
+    switch ( x ) {
+        case 0:
+            ++x;
+            break;
+        default:
+            break;
+        case 1:
+        case 2:
+            break;
+    }
+}`;
+
+const failingCode2 = 
+`void foo16_5_4( void )
+{
+    int x;
+    switch ( x ) {
+        case 0:
+            ++x;
+            break;
+        case 1:
+        case 2:
+            break;
+        case 5:
+        case 10:
+        default:
+        case 6:
+        case 8:
+            break;
+    }
+}`;
+
+const failingCode3 = 
+`void foo16_5_5( void )
+{
+    int x;
+    switch ( x ) {
+        case 0:
+            ++x;
+            break;
+        case 1:
+        case 2:
+            break;
+        case 5:
+        case 10:
+        default:
+        case 6:
+        case 8:
+            break;
+        case 7:
+            break;
+    }
+}`;
+
+const failingCode4 = 
+`void foo16_5_6( void )
+{
+    int x;
+    switch ( x ) {
+        case 0:
+            ++x;
+            break;
+        case 5:
+        case 6:
+        default:
+            break;
+        case 1:
+        case 2:
+            break;
+    }
+}`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode1 },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
+    { name: "bad4.c", code: failingCode4 },
+    { name: "good.c", code: passingCode1 },
+];
+
+describe("Rule 16.5", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(4);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad1.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad2.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad3.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad4.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

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

@@ -0,0 +1,146 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import { FileJp, FunctionJp, If, Switch } from "@specs-feup/clava/api/Joinpoints.js";
+
+const passingCode = 
+`void foo16_6_1( void )
+{
+    int x, a, b;
+
+    switch ( x )
+    {
+        case 0:
+            a = 10;
+            break; 
+        default:
+            break; 
+    }
+
+    switch ( x )
+    {
+        default:
+            a = 10;
+            break; 
+        case 1:
+        case 2:
+            break; 
+    }
+}`;
+
+const failingCode1 = 
+`int foo16_6_2( void )
+{
+    int x = 1;
+    switch ( x )
+    {
+        default: /* Non-compliant*/
+            break;  
+    }
+
+    switch ( x )
+    {
+        case 1: /* Non-compliant*/
+        default:
+            break;  
+    }
+    return x;
+}`;
+
+const failingCode2 = 
+`int foo16_6_3( void )
+{
+    int x = 10, a, b;
+
+    switch ( x )
+    {
+        case 1: 
+        case 3:
+        default:
+            a = 10;
+            b = a * 2;
+            break;  
+    }
+    return x;
+}`;
+
+// 2 erros: one is related to not having a default case
+const failingCode3 = 
+`int foo16_6_4( void )
+{
+    int x = 10, a, b;
+
+    switch ( x )
+    {
+        case 1: /* Non-compliant*/
+        case 3:
+            a = 10;
+            b = a * 2;
+            break;  
+    }
+    return x;
+}`;
+
+const failingCode4 = 
+`int foo16_6_5( void )
+{
+    int x = 10, a, b;
+
+    switch ( x )
+    {
+        case 1: /* Non-compliant*/
+        case 3:
+        default:
+            a = 10;
+            b = a * 2;
+            if (a + b > 14) {
+                a = 0;
+                break;
+            }
+            b = 15;
+            break;  
+    }
+    return x;
+}`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode1 },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
+    { name: "bad4.c", code: failingCode4 },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 16.6", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in non-compliant files", () => {
+        expect(countMISRAErrors()).toBe(6);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad1.c"}).first()!)).toBe(2);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad2.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad3.c"}).first()!)).toBe(2);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad4.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in non-compliant files", () => {
+        expect(countErrorsAfterCorrection()).toBe(1);
+
+        const badFile = Query.search(FileJp, {name: "bad1.c"}).first()!;
+        expect(Query.searchFrom(badFile, Switch).get().length).toBe(0);
+        expect(Query.searchFrom(badFile, If).get().length).toBe(0);
+        expect(Query.searchFrom(badFile, FunctionJp).first()?.body.children.length).toBe(2);
+
+        const bad2File = Query.search(FileJp, {name: "bad2.c"}).first()!;
+        expect(Query.searchFrom(bad2File, Switch).get().length).toBe(0);
+        expect(Query.searchFrom(bad2File, If).get().length).toBe(0);
+        expect(Query.searchFrom(bad2File, FunctionJp).first()?.body.children.length).toBe(4);
+
+        const bad3File = Query.search(FileJp, {name: "bad3.c"}).first()!;
+        expect(Query.searchFrom(bad3File, Switch).get().length).toBe(0);
+        expect(Query.searchFrom(bad3File, If).get().length).toBe(1);
+
+        const bad4File = Query.search(FileJp, {name: "bad4.c"}).first()!;
+        expect(Query.searchFrom(bad4File, Switch).get().length).toBe(1);
+    });
+});

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

@@ -0,0 +1,102 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import { FileJp } from "@specs-feup/clava/api/Joinpoints.js";
+
+const passingCode = 
+`void foo16_7_1( int num )
+{
+    switch (num) { 
+        case 0:
+            num *= 2;
+            break;
+        case 1:
+            num += 5;
+            break;
+        default:
+            num -= 3;
+            break;
+    }
+}`;
+
+const failingCode1 = 
+`
+#include <stdbool.h>
+
+void foo16_6_2( int num )
+{
+    int a = 7;
+    switch (num % 3) { 
+        case 0:
+            a *= 2;
+            break;
+        case 1:
+            a += 5;
+            break;
+        default:
+            a -= 3;
+            break;
+    }
+}
+    
+void foo16_6_3( bool flag )
+{
+    int a = 7;
+    switch (flag) { 
+        case 1:
+            a *= 2;
+            break;
+        case 0:
+            a += 5;
+            break;
+        default:
+            a -= 3;
+            break;
+    }
+}
+`;
+
+const failingCode2 = 
+`
+#include <stdbool.h>
+
+void foo16_6_4( bool flag )
+{
+    int a = 7, b = 10;
+    switch (flag) { 
+        case 1:
+            a *= 2;
+            if (a * a > 10) {
+                b = 12;
+                break;
+            }
+            break;
+        case 0:
+            a += 5;
+            break;
+        default:
+            a -= 3;
+            break;
+    }
+}`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode1 },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 16.7", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(3);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad1.c"}).first()!)).toBe(2);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad2.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(1);
+    });
+});

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

@@ -0,0 +1,79 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const passingCode = `
+#include <stdio.h>
+int func() {
+    return 0;
+}
+
+void test_17_3_1() {
+    printf("Result: %.2f ", func());
+}`;
+
+const failingCode = `
+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 printf(): studio.h is missing
+    // Return value is not being used
+    printf("Results: %.2f %.2f ", res1, res2);
+    
+    // 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);
+
+    // Implicit call to print(): studio.h will not solve this issue
+    // Return value is not being used
+    (void) print("End of program");
+
+}`;
+
+const failingCode2 = `
+#include <math.h>
+
+int func() {
+    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);
+
+    return 0;
+}`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "good.c", code: passingCode },
+];
+
+describe("Rule 17.4", () => {
+    registerSourceCode(files);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(12);
+    });
+
+    it("should correct errors", () => {
+        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);
+    });
+});