@specs-feup/clava-misra 1.0.0 → 1.0.2

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

@@ -0,0 +1,98 @@
+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"; 
+import path from "path";
+import { fileURLToPath } from "url";
+
+const passingCode = `
+unsigned int test_17_4_1() {
+    return 0;  
+}`;
+
+const failingCode = `
+unsigned int test_17_4_2() {
+
+}`;
+
+const failingCode2 = `
+float test_17_4_3() {
+
+}`;
+
+const failingCode3 = `
+    enum Status { 
+        FAIL, 
+        SUCCESS
+    };
+
+    typedef enum {
+        RED,
+        GREEN, 
+    } Color;
+
+     typedef enum {
+        SMALL,
+        LARGE
+    } Size;
+
+    typedef unsigned int my_int_type;
+
+    // Non-compliant
+    enum Status test_17_4_3() {
+
+    }
+
+    // Non-compliant
+    Color test_17_4_4() {
+
+    }
+
+    // Non-compliant
+    my_int_type test_17_4_5() {
+    
+    }
+
+    /* 
+        Non-compliant after correction:
+        Config file specifies an invalid default value for 'Size' type (e.g: MEDIUM)
+    */
+    Size test_17_4_6() {
+
+    }
+
+    /* 
+        Non-compliant after correction: 
+        Config file do not specify the default value for 'double' type
+    */
+    double test_17_4_7() { 
+    }
+`;
+
+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.4", () => {
+    registerSourceCode(files);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(7);
+        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(5);
+        expect(countMISRAErrors(Query.search(FileJp, { name: "good.c" }).first()!)).toBe(0);
+    });
+
+    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(2);
+    });
+});

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

@@ -0,0 +1,77 @@
+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 = `
+unsigned int test_17_4_1() {
+    return 0;  
+}`;
+
+const failingCode = `
+unsigned int test_17_4_2() {
+
+}`;
+
+const failingCode2 = `
+float test_17_4_3() {
+
+}`;
+
+const failingCode3 = `
+    enum Status { 
+        FAIL, 
+        SUCCESS
+    };
+
+    typedef enum {
+        RED,
+        GREEN, 
+    } Color;
+
+    typedef unsigned int my_int_type;
+
+    // Non-compliant
+    enum Status test_17_4_3() {
+
+    }
+
+    // Non-compliant
+    Color test_17_4_4() {
+
+    }
+
+    // Non-compliant
+    my_int_type test_17_4_5() {
+    
+    }
+
+    /* 
+        Non-compliant after correction: 
+        Config file do not specify the default value for 'double' type
+    */
+    double test_17_4_6() { 
+    }
+`;
+
+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.4 (without config)", () => {
+    registerSourceCode(files);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(6);
+        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(4);
+        expect(countMISRAErrors(Query.search(FileJp, { name: "good.c" }).first()!)).toBe(0);
+    });
+
+    it("should correct errors", () => {
+        expect(countErrorsAfterCorrection()).toBe(6);
+    });
+});

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

@@ -0,0 +1,36 @@
+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 test_17_6_1(int my_array[]) {
+    return my_array[0];  
+}`;
+
+const failingCode = `
+int test_17_6_2(int my_array[static 10]) {
+    return my_array[0];  
+}`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 17.6", () => { 
+    if (process.env.STD_VERSION === "c90")  {
+        it("should skip tests for c90", () => {});
+    } else {
+        registerSourceCode(files);
+
+        it("should detect errors in bad.c", () => {
+            expect(countMISRAErrors()).toBe(1); 
+            expect(countMISRAErrors(Query.search(FileJp, { name: "bad.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/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,19 @@
+{
+  "defaultValues": {
+    "int": 0,
+    "unsigned int": 0,  
+    "float": 0.0,
+    "enum Status": "SUCCESS",
+    "Color": "RED",
+    "Size": "MEDIUM",
+    "my_int_type": 0
+  },
+  "implicitCalls": {
+    "printf": "stdio.h",
+    "print": "stdio.h",
+    "sin": "math.h",
+    "pow": "math.h",
+    "half": "math.h",
+    "println": "stdio.h"
+  }
+}

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);
+    });
+});