@specs-feup/clava-misra 1.0.0 → 1.0.1

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

@@ -0,0 +1,44 @@
+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 programCode = `
+    void my_void_func() {
+        // Void function 
+    }
+
+    unsigned int foo() {
+        return 0;
+    }
+
+    unsigned int bar(unsigned int n) {
+        return n*n;
+    }
+
+    int main() {
+        my_void_func(); // Compliant - call to void function
+
+        unsigned int result = foo();
+        (void) bar(foo()); 
+
+        foo(); // Non-compliant
+        
+        return 0;
+    }   
+`;
+
+const files: TestFile[] = [
+    { name: "program.c", code: programCode }
+];
+
+describe("Rule 17.7", () => {
+    registerSourceCode(files);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(1);
+    });
+
+    it("should correct errors", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section17_Functions/misra_config.json

@@ -0,0 +1,10 @@
+{
+    "defaultValues": {
+      "int": 0,
+      "unsigned int": 0,  
+      "float": 0.0,
+      "enum Status": "SUCCESS",
+      "Color": "RED",
+      "my_int_type": 0
+    }
+}

package/src/tests/Section2_UnusedCode/Rule_2_3_UnusedTypeDecl.test.ts

@@ -0,0 +1,175 @@
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import { EnumDecl, FileJp, RecordJp, TypedefDecl } from "@specs-feup/clava/api/Joinpoints.js";
+
+const passingCode = `
+    typedef int MyInt;
+    typedef MyInt AliasInt;
+
+    typedef int BasicInt;
+    typedef BasicInt* PtrToBasicInt;
+
+    typedef int MyInt2;
+    typedef int MyInt3;
+    typedef int MyInt4;
+
+    typedef struct {
+        int x;
+        int y; 
+        MyInt2 i2;       
+        MyInt3 i3[4];  
+        MyInt4 *i4;   
+    } MyStruct;
+
+    typedef int MyInt5;
+    typedef union {
+        int x;
+        int y; 
+        MyInt5 i5;
+    } MyUnion;
+
+    typedef int BasicInt2;
+    void foo(BasicInt2 x) {
+        int a = x + 1;
+    }
+
+    typedef int BasicInt3;
+    BasicInt3 bar() {
+        return (BasicInt3)10;
+    }
+
+    int main() {
+        AliasInt a = 1;
+        BasicInt x = 10;
+        MyInt4 y = 11;
+
+        MyStruct myStructInstance = {1, 2, 3, {4, 5, 6, 7}, &y};
+
+        MyUnion myUnionInstance;
+        myUnionInstance.x = 100;
+
+        PtrToBasicInt ptr = &x;
+
+        return 0;
+    }`;
+
+// 3 errors
+const failingCode1 = ` 
+    typedef int OtherInt;
+
+    // Unused type defs
+    typedef OtherInt** OtherPointer;
+    typedef int MyUnusedType;
+    typedef int** MyUnusedPointer;
+`;
+
+// 4 errors, where 1 is the unused tag decl
+const failingCode2 = `
+    // Should be removed
+    typedef struct {
+        int x;
+        int y; 
+    } MyUnusedStruct;
+
+    // Should be removed
+    typedef struct NumberEnum {
+        int x;
+        int y; 
+    } MyUnusedStruct2;
+
+    // Should be replaced by the struct
+    typedef struct PersonStruct {
+        int id;
+        char name[10];
+    } Person;
+    struct PersonStruct personInstance = {1, "Alice"};
+`;
+
+// 4 errors, one is from the other class
+const failingCode3 = `
+    // Should be removed
+    typedef union {
+        int x;
+        int y; 
+    } MyUnusedUnion1;
+
+    // Should be removed
+    typedef union NumberUnion1 {
+        int x;
+        int y; 
+    } MyUnusedUnion2;
+    
+    // Should be replaced by the union
+    typedef union NumberUnion {
+        int intValue;
+        float floatValue;
+    } Number;
+
+    union NumberUnion unionInst = {.intValue = 10};
+`;
+
+// 4 errors, one is from the other class
+const failingCode4 = `
+    // Should be removed
+    typedef enum {
+        A1,
+        B1,
+        C1
+    } MyUnusedEnum;
+
+    // Should be removed
+    typedef enum ColorEnum2 {
+        YELLOW,
+        BROWN,
+        WHITE
+    } Color2;
+
+    // Should be replaced by the enum
+    typedef enum ColorEnum {
+        RED,
+        GREEN,
+        BLUE
+    } Color;
+    enum ColorEnum colorInstance = GREEN;  
+`;
+
+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 2.3", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(15);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad1.c"}).first()!)).toBe(3);
+        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: "bad4.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(0);
+
+        const badFile1 = Query.search(FileJp, {name: "bad1.c"}).first()!;
+        expect(Query.searchFrom(badFile1, TypedefDecl).get().length).toBe(0);
+
+        const badFile2 = Query.search(FileJp, {name: "bad2.c"}).first()!;
+        expect(Query.searchFrom(badFile2, TypedefDecl).get().length).toBe(0);
+        expect(Query.searchFrom(badFile2, RecordJp).get().length).toBe(1);
+
+        const badFile3 = Query.search(FileJp, {name: "bad3.c"}).first()!;
+        expect(Query.searchFrom(badFile3, TypedefDecl).get().length).toBe(0);
+        expect(Query.searchFrom(badFile3, RecordJp).get().length).toBe(1);
+
+        const badFile4 = Query.search(FileJp, {name: "bad4.c"}).first()!;
+        expect(Query.searchFrom(badFile4, TypedefDecl).get().length).toBe(0);
+        expect(Query.searchFrom(badFile4, EnumDecl).get().length).toBe(1);
+    });
+});

package/src/tests/Section2_UnusedCode/Rule_2_4_UnusedTagDecl.test.ts

@@ -0,0 +1,219 @@
+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 failingCodeEnum1 = `
+    enum MyEnum { 
+        RED, GREEN, BLUE 
+    };
+
+    enum EnumForCast1 {
+        RED2, GREEN2, BLUE2
+    };
+
+    enum EnumForCast2 {
+        RED3, GREEN3, BLUE3
+    };
+
+    enum MyEnum2 {
+        RED4, GREEN4, BLUE4
+    };
+
+    enum EnumForPtr {
+        RED5, GREEN5, BLUE5
+    };
+
+    enum EnumForArray {
+        RED6, GREEN6, BLUE6
+    };
+
+    // Non-compliant
+    enum UnusedEnum {
+        RED7, GREEN7, BLUE7
+    };
+
+    void enumAsParam(enum MyEnum color) {
+        int i;
+        if (color == RED) {
+            i = 1;
+        }
+    }
+
+    enum EnumForCast1 enumAsReturn() {
+        return (enum EnumForCast1) RED2;
+    };
+
+    enum EnumForCast2 enumAsReturn2() {
+        int id = 2;
+        return (enum EnumForCast2) id;
+    };
+
+    enum MyEnum2 color_enum = RED4;
+
+    enum EnumForPtr *colorPtr;
+
+    enum EnumForArray colorArray[3];
+`;
+
+const failingCodeEnum2 = `
+    typedef enum {
+        A1,
+        B1,
+        C1
+    } ColorEnum2;
+    ColorEnum2 colorEnum2 = A1;
+
+    typedef enum MyColors {
+        A2,
+        B3,
+        C4
+    } ColorOption;
+    enum MyColors my_color = A2;
+    ColorOption color_option = B3;
+
+    // MyColors2 tag should be removed
+    typedef enum MyColors2 {
+        A5,
+        B6,
+        C7
+    } ColorOption2;
+    ColorOption2 color2 = B6;
+`;
+
+const failingCodeStruct1 = `
+    struct MyStruct {
+        int x;
+        float y;
+    };
+
+    struct StructForReturn1 {
+        int x;
+        float y;
+    };
+
+    struct MyStruct2 {
+        int x;
+        float y;
+    };
+
+    struct StructForPtr {
+        int x;
+        float y;
+    };
+
+    struct StructForArray {
+        int x;
+        float y;
+    };
+
+    // Non-compliant: should be removed
+    struct UnusedStruct {
+        int x;
+        float y;
+    };
+
+    void structAsParam(struct MyStruct s) {
+        int xField = s.x;
+    }
+
+    struct StructForReturn1 structAsReturn() {
+        return (struct StructForReturn1){1, 1.5f};
+    }
+
+    struct MyStruct2 myStruct = {10, 20.5f};
+    struct StructForPtr *structPtr;
+    struct StructForArray structArray[3];
+`;
+
+const failingCodeStruct2 = `
+    typedef struct {
+        int x;
+        float y;
+    } ColorStruct;
+    ColorStruct colorStruct = {1, 2.5};
+
+    typedef struct MyStruct5 {
+        int x;
+        float y;
+    } ColorStruct2;
+    struct MyStruct5 struct5 = {2, 4.5};
+    ColorStruct2 colorStruct2 = {1, 2.5};
+
+    // Violation: MyStruct3 tag will be removed
+    typedef struct MyStruct3 { 
+        int x;
+        float y;
+    } ColorStruct3;
+    ColorStruct3 colorStruct3 = {10, 5.5};
+`;
+
+const failingCodeUnion1 = `
+    union MyUnion {
+        int x;
+        float y;
+    };
+
+    union UnionForReturn1 {
+        int x;
+        float y;
+    };
+
+    union MyUnion2 {
+        int x;
+        float y;
+    };
+
+    union UnionForPtr {
+        int x;
+        float y;
+    };
+
+    union UnionForArray {
+        int x;
+        float y;
+    };
+
+    // Non-compliant: should be removed
+    union UnusedUnion {
+        int x;
+        float y;
+    };
+
+    void unionAsParam(union MyUnion u) {
+        int xField = u.x;
+    }
+
+    union UnionForReturn1 unionAsReturn() {
+        return (union UnionForReturn1){.x = 1};
+    }
+
+    union MyUnion2 myUnion = {.y = 20.5f};
+    union UnionForPtr *unionPtr;
+    union UnionForArray unionArray[3];
+`;
+
+const files: TestFile[] = [
+    { name: "testEnum1.c", code: failingCodeEnum1 },
+    { name: "testEnum2.c", code: failingCodeEnum2 },
+    { name: "testStruct1.c", code: failingCodeStruct1 },
+    { name: "testStruct2.c", code: failingCodeStruct2 },
+    { name: "testUnion1.c", code: failingCodeUnion1 },
+];
+
+describe("Rule 2.4", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(5);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "testEnum1.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "testEnum2.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "testStruct1.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "testStruct2.c"}).first()!)).toBe(1);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "testUnion1.c"}).first()!)).toBe(1);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section2_UnusedCode/Rule_2_6_UnusedLabels.test.ts

@@ -0,0 +1,49 @@
+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 = `
+    int test1() {
+        int x = 0;
+        goto label1;
+
+        label1: 
+            x++;
+
+        return 0;
+    }`;
+
+const failingCode = `
+    int test2() {
+        int x = 0;
+        label1: 
+            x = 1;
+            label2:
+                x++;
+
+        goto label3;
+
+        label3: 
+            x += 4;
+        return 0;
+    }`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 2.6", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(2);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(2);
+        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/Section2_UnusedCode/Rule_2_7_UnusedParameters.test.ts

@@ -0,0 +1,55 @@
+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 failingCode = `
+    int foo(int x, int y, int z); 
+
+    int foo(int x, int y, int z) { 
+        y++;
+        return y;
+    }
+
+    int main() {
+        int a = 5, b = 10, c = 15;
+        int result1 = foo(a, b, c);
+
+        int result2 = result1 + foo(a, b, c);
+        
+        return result2;
+    }`;
+
+const passingCode = `
+    extern int foo(int x, int y, int z);
+
+    int my_func(int x, int y, int z) {
+        return x + y + z;
+    }
+        
+    int my_func2() {
+        return 0;
+    }
+
+    int bar() { 
+        return my_func(1, 2, 3) + foo(50, 51, 52);
+    }`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 2.7", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(2);
+        
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(2);
+        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/Section3_Comments/Rule_3_1_CommentSequences.test.ts

@@ -0,0 +1,37 @@
+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 = `int main() {
+    int x, y, z;// good inline comment
+    // good */ comment
+    return 0;
+}`;
+
+const failingCode = `int test() {
+    int x, y, z; // bad inl/*ine comment
+
+    /* bad /* block comment */
+
+    return 0;
+}`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 3.1", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(2);
+
+        expect(countMISRAErrors(Query.search(FileJp, {name: "bad.c"}).first()!)).toBe(2);
+        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/utils.ts

@@ -0,0 +1,39 @@
+import MISRATool from "../MISRATool.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+import { FileJp, Program } from "@specs-feup/clava/api/Joinpoints.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+
+export function countMISRAErrors(startingPoint: FileJp | Program = Query.root() as Program): number {
+  MISRATool.checkCompliance(startingPoint);
+  return MISRATool.getMISRAErrors().length;
+}
+
+export function countErrorsAfterCorrection(configPath?: string): number {
+  MISRATool.applyCorrections(configPath);
+  return MISRATool.getMISRAErrors().length;
+}
+
+export interface TestFile {
+    name: string,
+    code: string
+    path?: string
+}
+
+export function registerSourceCode(files: TestFile[]): void {
+    beforeEach(() => {
+      Clava.getData().setStandard(process.env.STD_VERSION!);
+      Clava.getProgram().push();
+      const program = Clava.getProgram();
+      files.forEach(file => {
+        const sourceFile = ClavaJoinPoints.fileWithSource(file.name, file.code, file.path);
+        program.addFile(sourceFile);
+      });
+      program.rebuild();
+    });
+  
+    afterEach(() => {
+      Clava.getProgram().rebuild();
+      Clava.getProgram().pop();
+    });
+}