@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/tests/Section5_Identifiers/Rule_5_1_DistinctExternalIdentifiers.test.ts

@@ -0,0 +1,78 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+
+const failingCode = `
+#include <stdint.h>
+
+/*      1234567890123456789012345678901********* Characters */
+int32_t engine_exhaust_gas_temperature_raw;
+int32_t engine_exhaust_gas_temperature_scaled; /* Non-compliant */
+
+/*      1234567890123456789012345678901********* Characters */
+int32_t engine_exhaust_gas_temp_raw;
+int32_t engine_exhaust_gas_temp_scaled; /* Compliant */
+
+/*   1234567890123456789012345678901********* Characters */
+void motor_controller_status_update_v1(void) {
+    return;
+}
+
+/*   1234567890123456789012345678901********* Characters */
+void motor_controller_status_update_v2(void) { /* Non-compliant */
+    return;
+}
+
+/*      1234567890123456789012345678901********* Characters */
+int32_t data_collection_handler_buffer_var;
+
+/*   1234567890123456789012345678901********* Characters */
+void data_collection_handler_buffer_function(void) { /* Non-compliant */
+    return;
+}
+`;
+
+const systemFile = `
+#include <stdint.h>
+
+extern int32_t engine_exhaust_gas_temperature_raw;
+extern int32_t engine_exhaust_gas_temperature_scaled; 
+
+extern int32_t engine_exhaust_gas_temp_raw;
+extern int32_t engine_exhaust_gas_temp_scaled;
+
+extern void motor_controller_status_update_v1(void);
+extern void motor_controller_status_update_v2(void);
+
+extern int32_t data_collection_handler_buffer_var;
+extern void data_collection_handler_buffer_function(void);
+
+static void use_externs_5_1() {
+    (void) (engine_exhaust_gas_temperature_raw);
+    (void) (engine_exhaust_gas_temperature_scaled);
+    (void) (engine_exhaust_gas_temp_raw);
+    (void) (engine_exhaust_gas_temp_scaled);
+    motor_controller_status_update_v1();
+    motor_controller_status_update_v2();
+
+    (void) (data_collection_handler_buffer_var);
+
+    data_collection_handler_buffer_function();
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "system.c", code: systemFile }
+];
+
+describe("Rule 5.1", () => {
+    registerSourceCode(files);
+
+    it("should detect violations of Rule 5.1", () => {
+        expect(countMISRAErrors()).toBe(3);
+        expect(countMISRAErrors("5.1")).toBe(3);
+    });
+
+    it("should correct all violations of Rule 5.1", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section5_Identifiers/Rule_5_6_UniqueTypedefNames.test.ts

@@ -0,0 +1,120 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+
+const failingCode1 = `
+#include <stdint.h>
+#include <stddef.h> 
+typedef float float32_t;  
+
+static void test_5_6_1 ( void ) {
+    {
+        typedef unsigned char u8_t;
+        u8_t var_1 = 288; 
+    }
+
+    {
+        typedef unsigned char u8_t; // Violation of rule 5.6
+        u8_t var_2 = 288; 
+    }
+}
+
+typedef float mass;
+
+static void test_5_6_2 ( void ) {
+    float32_t mass = 0.0f; // Violation of rule 5.6
+}
+
+typedef struct list {
+    struct list *next;
+    uint16_t element;
+} list; /* Compliant - exception */
+
+typedef struct { // Violation of rule 5.7
+    struct chain // Violation of rule 5.6
+    {
+        struct chain *list;
+        uint16_t element;
+    } s1;
+
+    uint16_t length;
+} chain; /* Non-compliant - tag "chain" not
+* associated with typedef */
+
+static void test_5_6_7() {
+    mass var_3 = 0.0f;
+    list list_var = { .next = NULL, .element = 0 };
+    chain chain_var = { .s1 = { .list = NULL, .element = 0 }, .length = 0 };
+}
+`;
+
+const failingCode2 = `
+typedef unsigned int my_int; // Violation of rule 5.7
+
+struct my_int { // Violation of rule 5.6
+    float x;
+    float y;
+};
+
+static unsigned int test_5_6() {
+    my_int value = 42; 
+    struct my_int point = { 1.5f, 2.5f };
+
+    return 0;
+}
+`;
+
+const failingCode3 = `
+#include <stdint.h>
+#include <stddef.h>
+
+typedef float float_type;
+
+static void compute_5_6(void) {
+    {
+        typedef int8_t byte_t;
+        byte_t x = 1;
+    }
+
+    {
+        typedef int8_t byte_t; // Violation of rule 5.6
+        byte_t y = 2;
+    }
+}
+
+typedef float velocity;
+
+static void simulate(void) {
+    velocity vel = 90;
+    float_type velocity = 99.5; // Violation of rule 5.6
+    
+}
+
+typedef struct node {
+    struct node *next;
+    uint16_t id;
+} node; /* Compliant - exception */
+
+static void traverse(node *head) {
+    while (head != NULL) {
+        head = head->next;
+    }
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode1 },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
+];
+
+describe("Rule 5.6", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(8);
+        expect(countMISRAErrors("5.6")).toBe(6);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection("5.6")).toBe(0);
+    });
+});

package/src/tests/Section5_Identifiers/Rule_5_7_UniqueTagNames.test.ts

@@ -0,0 +1,51 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+
+const failingCode1 = `
+#include <stdint.h>
+
+struct deer {
+    uint16_t a;
+    uint16_t b;
+};
+
+static void foo ( void ) {
+    struct deer { // Violation of rule 5.7
+        uint16_t a;
+    }; 
+    struct deer deer1 = { 5 };
+}
+
+typedef struct coord {
+    uint16_t x;
+    uint16_t y;
+} coord; /* Compliant by Exception */
+
+struct elk {
+    uint16_t x;
+};
+
+static void test_5_7_1() {
+    struct deer deer_var = {100, 200};
+    coord coord_var = {50, 60}; 
+    struct coord coord_struct; 
+    struct elk elk_var = {100}; 
+}
+`;
+
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode1 }
+];
+
+describe("Rule 5.7", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(1);
+        expect(countMISRAErrors("5.7")).toBe(1);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection("5.7")).toBe(0);
+    });
+});

package/src/tests/Section5_Identifiers/Rule_5_8_UniqueExternalLinkIdentifiers.test.ts

@@ -0,0 +1,73 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+
+const file1 = `
+#include <stdint.h>
+
+int32_t count_5_8; 
+
+void foo_5_8 ( void ) { // Violation of rule 5.9
+    int16_t index_5_8; 
+}
+`;
+
+const file2 = `
+#include <stdint.h>
+
+static void foo_5_8 ( void ) {  // Violation of rule 5.8
+    int16_t count_5_8; // Violation of rule 5.8
+    int32_t index_5_8; 
+}
+`;
+
+const file3 = `
+#include <stdint.h>
+
+static void test_5_8_1 ( void ) { 
+    int32_t index_5_8 = 0;
+
+    count_5_8: // Violation of rule 5.8
+        index_5_8++;
+    if (index_5_8 < 5) {
+        goto count_5_8;
+    }
+}
+
+static void test_5_8_2(void) {  
+    int32_t foo_5_8 = 0; // Violation of rules 5.8 and 5.9
+}
+`;
+
+const systemFile = `
+#include <stdint.h>
+extern int32_t count_5_8;
+extern void foo_5_8 (void);
+
+static void use_externs_5_8() { 
+    (void) (count_5_8);
+    foo_5_8();
+}
+`;
+
+const files: TestFile[] = [
+    { name: "file1.c", code: file1 },
+    { name: "file2.c", code: file2 },
+    { name: "file3.c", code: file3 },
+    { name: "rule_5_8_system.c", code: systemFile}
+];
+
+describe("Rule 5.8", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(6);
+        expect(countMISRAErrors("5.8")).toBe(4);
+
+        //expect(countMISRAErrors(Query.search(FileJp, {name: "good.c"}).first()!, "5.8")).toBe(0);
+        //expect(countMISRAErrors(Query.search(FileJp, {name: "bad1.c"}).first()!, "5.8")).toBe(2);
+        //expect(countMISRAErrors(Query.search(FileJp, {name: "bad2.c"}).first()!, "5.8")).toBe(3);
+    });
+
+    it("should correct errors in bad.c", () => {
+         expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section5_Identifiers/Rule_5_9_UniqueInternalLinkIdentifiers.test.ts

@@ -0,0 +1,97 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+
+const failingCode1 = `
+#include <stdint.h>
+
+static int32_t count_5_9; /* "count" has internal linkage */
+
+static void foo_5_9 (void) { 
+    int16_t count_5_9; // Violation of rule 5.9
+    int16_t index_5_9; 
+}
+
+void bar1 (void) {
+    static int16_t count_5_9;  // Violation of rule 5.9
+    foo_5_9();
+}
+
+void static use_static_count() {
+    (void) count_5_9;
+}
+
+void static use_static_count_2() {
+    (void) count_5_9;
+}
+`;
+
+const failingCode2 = `
+#include <stdint.h>
+
+static int8_t count_5_9; // Violation of rule 5.9
+
+static void foo_5_9 ( void ) { // Violation of rule 5.9
+    int32_t index_5_9;
+    int16_t nbytes; 
+}
+
+// Missing "static" keyword
+void bar2 ( void ){
+    static uint8_t nbytes; 
+}
+
+void static use_static_count_3() {
+    (void) count_5_9;
+}
+
+void static use_static_count_4() {
+    (void) count_5_9;
+}
+`;
+
+const failingCode3 = `
+#include <stdint.h>
+
+static void test_5_9_1 ( void ) { 
+    int32_t index_5_9 = 0;
+
+    count_5_9: // Violation of rule 5.9
+        index_5_9++;
+    if (index_5_9 < 5) {
+        goto count_5_9;
+    }
+}
+`;
+
+const systemFile = `
+extern void bar1 (void);
+extern void bar2 (void);
+
+static void use_externs_5_9() {
+    bar1();
+    bar2();
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode1 },
+    { name: "bad2.c", code: failingCode2 },
+    { name: "bad3.c", code: failingCode3 },
+    { name: "rule_5_9_system.c", code: systemFile}
+];
+
+describe("Rule 5.9", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(5);
+        expect(countMISRAErrors("5.9")).toBe(5);
+
+        //expect(countMISRAErrors(Query.search(FileJp, {name: "bad1.c"}).first()!)).toBe(5);
+        //expect(countMISRAErrors(Query.search(FileJp, {name: "bad2.c"}).first()!)).toBe(3);
+        //expect(countMISRAErrors(Query.search(FileJp, {name: "bad3.c"}).first()!)).toBe(1);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section8_DeclarationsAndDefinitions/Rule_8_6_SingleExternalDefinition.test.ts

@@ -0,0 +1,160 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+
+const passingCode1 = `
+#include <stdint.h>
+
+/* Compliant - First definition but has another initialization in other file
+* Will not be fixed, as there are multiple initializations
+*/
+int16_t i = 10;
+`;
+
+const failingCode1 = `
+#include <stdint.h>
+
+/*
+* Non-compliant - Second definition
+* Will not be fixed, as there are multiple initializations
+*/
+int16_t i = 20;
+`;
+
+const passingCode2 = `
+#include <stdint.h>
+
+int16_t j; /* Tentative definition */
+int16_t j = 1; /* Compliant - external definition */
+`;
+
+const passingCode3 = `
+#include <stdint.h>
+
+/* Compliant - First defintion but has initialization in other file
+* After transformation it will have 'extern' storage class
+*/
+int16_t k; /* Tentative definition - becomes external */
+`;
+
+const failingCode3 = `
+#include <stdint.h>
+
+int16_t k = 0; /* Non-compliant- Second external definition (unique initialization)*/
+`;
+
+const failingCode4 = `
+#include <stdint.h>
+
+/* Compliant - First defintion but has initialization in other file
+* After transformation it will have 'extern' storage class
+*/
+int16_t a; 
+
+/* Compliant - First definition but has another initialization in other file
+*  Will not be fixed, as there are multiple initializations
+ */
+int16_t b = 40; 
+
+
+int16_t c; /* Compliant- First definition */
+`;
+
+const failingCode5 = `
+#include <stdint.h>
+
+/*
+* Non-compliant - Second definition
+* This is the unique initialization
+*/
+int16_t a = 10; 
+
+
+/*
+* Non-compliant - Second definition
+* Will not be fixed, as there are multiple initializations
+*/
+int16_t b = 20;
+
+
+/* 
+* Non-compliant - Second declaration
+* Will be changed to 'extern' 
+*/
+int16_t c; 
+`;
+
+const failingCode6 = `
+#include <stdint.h>
+
+/* 
+* Non-compliant - Third declaration
+* Will be changed to 'extern' 
+*/
+int16_t a;
+
+/*
+* Non-compliant - Second defintion
+* Will not be fixed, as there are multiple initializations
+*/
+int16_t b;
+`;
+
+const passingCode4 = `
+#include <stdint.h>
+
+int16_t d;
+int16_t e = 15;
+`;
+
+const passingCode5 = `
+#include <stdint.h>
+
+extern int16_t d;
+extern int16_t e;
+
+extern int16_t i;
+extern int16_t j;
+extern int16_t k;
+
+extern int16_t a;
+extern int16_t b;
+extern int16_t c;
+
+static int16_t findGreatestValue(void) {
+    int16_t values[] = { d, e, i, j, k, a, b, c };
+    int16_t max = values[0];
+
+    for (int idx = 1; idx < sizeof(values)/sizeof(values[0]); ++idx) {
+        if (values[idx] > max) {
+            max = values[idx];
+        }
+    }
+    return max;
+}
+`;
+
+const files: TestFile[] = [
+    { name: "good1.c", code: passingCode1 },
+    { name: "bad1.c", code: failingCode1 },
+    { name: "good2.c", code: passingCode2 },
+    { name: "good3.c", code: passingCode3 },
+    { name: "bad3.c", code: failingCode3 },
+    { name: "bad4.c", code: failingCode4 },
+    { name: "bad5.c", code: failingCode5 },
+    { name: "bad6.c", code: failingCode6 },
+    { name: "good4.c", code: passingCode4 },
+    { name: "good5.c", code: passingCode5 },
+];
+
+describe("Rule 8.6", () => {
+    registerSourceCode(files);
+
+    it("should detect errors in bad.c", () => {
+        expect(countMISRAErrors()).toBe(7);
+        expect(countMISRAErrors("8.6")).toBe(7);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(3);
+        expect(countErrorsAfterCorrection("8.6")).toBe(3);
+    });
+});

package/src/tests/Section8_DeclarationsAndDefinitions/Rule_8_7_RestrictExternalLinkage.test.ts

@@ -0,0 +1,46 @@
+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 good_extern_obj = 0;
+
+int good_extern_function() {
+    return ++good_extern_obj;
+}
+`;
+
+const failingCode = `
+extern int good_extern_obj;
+extern int good_extern_function();
+
+int bad_extern_obj = 0;
+
+int bad_extern_function() {
+    return bad_extern_obj + good_extern_obj + good_extern_function();
+}
+
+static int test_8_7_1() {
+    return bad_extern_obj;
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode }
+];
+
+describe("Rule 8.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/Section8_DeclarationsAndDefinitions/Rule_8_9_BlockScopeDefinition.test.ts

@@ -0,0 +1,69 @@
+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 = `
+#include <stdint.h>
+
+static uint32_t good_counter = 0;
+
+static void test_8_9_1 ( void ) {
+    int32_t i;
+    for (i = 0; i < 10; ++i) {
+
+    }
+    ++good_counter;
+}
+
+static uint32_t test_8_9_2 ( void ) {
+    static uint32_t call_count = 0;
+    
+    ++call_count;
+    ++good_counter;
+
+    return call_count;
+}
+`;
+
+const failingCode = `
+#include <stdint.h>
+
+static uint32_t bad_counter = 0; // Violation of rule 8.9
+
+static int test_8_9_3 (void) {
+    ++bad_counter;
+    return bad_counter;
+}
+`;
+
+const misraExample = `
+#include <stdint.h>
+
+static uint32_t test_8_9_4 ( void ) {
+    static uint32_t call_count = 0;
+    ++call_count;
+    return call_count;
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "good.c", code: passingCode },
+    { name: "misraExample.c", code: misraExample }
+];
+
+describe("Rule 8.9", () => {
+    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);
+        expect(countMISRAErrors(Query.search(FileJp, {name: "misraExample.c"}).first()!)).toBe(0);
+    });
+
+    it("should correct errors in bad.c", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});