@specs-feup/clava-misra 1.0.2 → 1.0.4

package/src/tests/Section21-StandardLibraries/Rule_21_3_NoDynamicMemory_ProblematicConfig.test.ts

@@ -0,0 +1,71 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const failingCode = `
+#include <stdlib.h>
+
+int main() {
+
+    // Provided fix has internal linkage
+    int *a = calloc(1, sizeof(int));
+
+    // Provided fix has different num of parameters
+    int *b = malloc(sizeof(int)); 
+
+    // Provided file does not include provided function name
+    a = realloc(a, 2 * sizeof(int));
+
+    // Config has missing parameters
+    free(a);
+    free(b);
+    return 0;
+}
+`;
+
+const customStdLib = `
+#include <stddef.h>
+
+static void* my_calloc(size_t num, size_t size) {
+    (void)num;
+    (void)size;
+    return NULL;
+}
+
+// Missing "static" keyword; Will have external decl after correction
+void* my_malloc(size_t num, size_t size) {
+    (void)num;
+    (void)size;
+    return NULL;
+}
+
+// Missing "static" keyword; Will have external decl after correction
+void my_free(void* ptr) {
+    (void)ptr;
+}
+`;
+
+
+const files: TestFile[] = [
+    { name: "bad1.c", code: failingCode },
+    { name: "custom_stdlib.c", code: customStdLib }
+];
+
+describe("Rule 21.3", () => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    const configFilename = "problematic_misra_config.json";
+    const configFilePath = path.join(__dirname, configFilename);
+
+    registerSourceCode(files, configFilePath);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(7);  
+        expect(countMISRAErrors("21.3")).toBe(5); 
+    });
+
+    it("should correct errors", () => {
+        expect(countErrorsAfterCorrection()).toBe(5);
+    });
+});

package/src/tests/Section21-StandardLibraries/Rule_21_6_NoStdIOFunctions.test.ts

@@ -0,0 +1,63 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const failingCode = `
+#include <stdio.h>  /* Non-compliant */
+
+static void test_21_6_1() {
+    char buffer[100];
+
+    // Non-compliant: call to stdlib function
+    (void) printf("Enter input: "); // Violation of rule 21.6
+}
+`;
+
+const customStdIO = `
+void my_printf(const char* fmt, ...) {
+    (void)fmt;
+}
+
+char* my_fgets(char* str, int num, void* stream) {
+    (void)str;
+    (void)num;
+    (void)stream;
+    return 0;
+}
+`;
+
+const systemFile = `
+extern void my_printf(const char* fmt, ...);
+extern char* my_fgets(char* str, int num, void* stream);
+
+static void use_externs_21_6() {
+    char buffer_21_6[10];
+    my_printf("Done");
+    (void) my_fgets(buffer_21_6, 10, 0);
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "custom_stdio.c", code: customStdIO },
+    { name: "rule_21_6_system.c", code: systemFile }
+];
+
+describe("Rule 21.6", () => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    const configFilename = "misra_config.json";
+    const configFilePath = path.join(__dirname, configFilename);
+
+    registerSourceCode(files, configFilePath);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(2);  
+        expect(countMISRAErrors("21.6")).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should correct errors", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section21-StandardLibraries/Rule_21_7_NoNumericStringConversions.test.ts

@@ -0,0 +1,91 @@
+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 failingCode_C90 = `
+#include <stdlib.h>
+
+int main() {
+    double d = atof("3.14");
+    int i = atoi("42");
+    long l = atol("123456");
+    return 0;
+}
+`;
+
+const failingCode_C99 = `
+#include <stdlib.h>
+
+int main() {
+    double d = atof("3.14");
+    int i = atoi("42");
+    long l = atol("123456");
+    long long ll = atoll("1234567890");
+    return 0;
+}
+`;
+
+const customStdLib = `
+#include <stddef.h>
+
+double my_atof(const char* str) {
+    (void)str;
+    return 0.0;
+}
+
+int my_atoi(const char* str) {
+    (void)str;
+    return 0;
+}
+
+long my_atol(const char* str) {
+    (void)str;
+    return 0L;
+}
+
+long long my_atoll(const char* str) {
+    (void)str;
+    return 0LL;
+}
+`;
+
+const systemFile = `
+extern double my_atof(const char* str);
+extern int my_atoi(const char* str);
+extern long my_atol(const char* str);
+extern long long my_atoll(const char* str);
+
+static void use_externs_21_7(void) {
+    (void) my_atof("3.14");
+    (void) my_atoi("42");
+    (void) my_atol("100000");
+    (void) my_atoll("9223372036854775807");
+}
+`;
+
+const stdVerstion = Clava.getStandard();
+const files: TestFile[] = [
+    { name: "bad1.c", code: stdVerstion === "c90" ? failingCode_C90 : failingCode_C99 },
+    { name: "custom_stdlib.c", code: customStdLib },
+    { name: "rule_21_7_system.c", code: systemFile }
+];
+
+describe("Rule 21.7", () => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    const configFilename = "misra_config.json";
+    const configFilePath = path.join(__dirname, configFilename);
+
+    registerSourceCode(files, configFilePath);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(stdVerstion === "c90" ? 3 : 4);  
+        expect(countMISRAErrors("21.7")).toBe(stdVerstion === "c90" ? 3 : 4); 
+    });
+
+    it("should correct errors", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section21-StandardLibraries/Rule_21_8_NoProcessControlFunctions.test.ts

@@ -0,0 +1,65 @@
+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 failingCode = `
+#include <stdlib.h>
+
+static int test_21_8_1() {
+    abort(); // Violation of rule 21.8
+    exit(1);  // Violation of rule 21.8
+    return 0;
+}
+`;
+
+// Custom implementations that will be used for correction
+const customStdLib = `
+#include <stddef.h>
+
+void my_abort(void) {
+    // safe replacement
+}
+
+void my_exit(int status) {
+    (void)status;
+    // safe replacement
+}
+`;
+
+const systemFile = `
+extern void my_abort(void);
+extern void my_exit(int status);
+
+static void use_externs_21_8() {
+    my_abort();
+    my_exit(1);
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: failingCode },
+    { name: "custom_stdlib.c", code: customStdLib },
+    { name: "rule_21_8_system.c", code: systemFile }
+];
+
+describe("Rule 21.8", () => {
+    if (Clava.getStandard() === "c11")  {
+        it("should skip tests for c11", () => {});
+    } else {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const configFilePath = path.join(__dirname, "misra_config.json");
+
+        registerSourceCode(files, configFilePath);
+
+        it("should detect errors", () => {
+            expect(countMISRAErrors()).toBe(2); 
+            expect(countMISRAErrors("21.8")).toBe(2); 
+        });
+
+        it("should correct errors", () => {
+            expect(countErrorsAfterCorrection()).toBe(0);
+        });
+    }
+});

package/src/tests/Section21-StandardLibraries/Rule_21_9_NoGenericSearchOrSort.test.ts

@@ -0,0 +1,89 @@
+import { countErrorsAfterCorrection, countMISRAErrors, registerSourceCode, TestFile } from "../utils.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const bad = `
+#include <stdlib.h>
+
+static int compare(const void* a, const void* b) {
+    return (*(int*)a - *(int*)b);
+}
+
+static int test_21_9_1() {
+    int arr1[] = { 5, 3, 1, 4, 2 };
+    int n1 = sizeof(arr1) / sizeof(arr1[0]);
+    qsort(arr1, n1, sizeof(int), compare); // Non-compliant
+
+    int arr2[] = { 1, 2, 3, 4, 5 };
+    int key = 3;
+    int n2 = sizeof(arr2) / sizeof(arr2[0]);
+    int* item = (int*)bsearch(&key, arr2, n2, sizeof(int), compare); // Non-compliant
+
+    return 0;
+}
+`;
+
+const customStdLib = `
+#include <stddef.h>
+
+void my_qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*)) {
+    (void)base;
+    (void)num;
+    (void)size;
+    (void)compar;
+}
+
+void* my_bsearch(const void* key, const void* base, size_t num, size_t size, int (*compar)(const void*, const void*)) {
+    (void)key;
+    (void)base;
+    (void)num;
+    (void)size;
+    (void)compar;
+    return NULL;
+}
+`;
+
+const systemFile = `
+#include <stddef.h>
+extern void my_qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*));
+extern void* my_bsearch(const void* key, const void* base, size_t num, size_t size, int (*compar)(const void*, const void*));
+
+static int compare_21_9(const void* a, const void* b) {
+    int arg1 = *(const int*)a;
+    int arg2 = *(const int*)b;
+    return (arg1 > arg2) - (arg1 < arg2);
+}
+
+static void use_externs_21_9(void) {
+    int arr[5] = {5, 3, 1, 4, 2};
+    int key = 3;
+
+    my_qsort(arr, 5, sizeof(int), compare_21_9);
+    (void) my_bsearch(&key, arr, 5, sizeof(int), compare_21_9);
+}
+`;
+
+const files: TestFile[] = [
+    { name: "bad.c", code: bad },
+    { name: "custom_stdlib.c", code: customStdLib },
+    { name: "rule_21_9_system.c", code: systemFile }
+];
+
+describe("Rule 21.9", () => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    const configFilename = "misra_config.json";
+    const configFilePath = path.join(__dirname, configFilename);
+
+    registerSourceCode(files, configFilePath);
+
+    it("should detect errors", () => {
+        expect(countMISRAErrors()).toBe(2);  
+        expect(countMISRAErrors("21.9")).toBe(2); 
+    });
+
+    it("should correct errors", () => {
+        expect(countErrorsAfterCorrection()).toBe(0);
+    });
+});

package/src/tests/Section21-StandardLibraries/misra_config.json

@@ -0,0 +1,88 @@
+{
+  "disallowedFunctions": {
+    "stdlib.h": {
+      "malloc": {
+        "replacement": "my_malloc",
+        "location": "custom_stdlib.c"
+      },
+      "calloc": {
+        "replacement": "my_calloc",
+        "location": "custom_stdlib.c"
+      },
+      "realloc": {
+        "replacement": "my_realloc",
+        "location": "custom_stdlib.c"
+      },
+      "free": {
+        "replacement": "my_free",
+        "location": "custom_stdlib.c"
+      },
+      "atof": {
+        "replacement": "my_atof",
+        "location": "custom_stdlib.c"
+      },
+      "atoi": {
+        "replacement": "my_atoi",
+        "location": "custom_stdlib.c"
+      },
+      "atol": {
+        "replacement": "my_atol",
+        "location": "custom_stdlib.c"
+      },
+      "atoll": {
+        "replacement": "my_atoll",
+        "location": "custom_stdlib.c"
+      },
+      "abort": {
+        "replacement": "my_abort",
+        "location": "custom_stdlib.c"
+      },
+      "exit": {
+        "replacement": "my_exit",
+        "location": "custom_stdlib.c"
+      },
+      "getenv": {
+        "replacement": "my_getenv",
+        "location": "custom_stdlib.c"
+      },
+      "system": {
+        "replacement": "my_system",
+        "location": "custom_stdlib.c"
+      },
+      "qsort": {
+        "replacement": "my_qsort",
+        "location": "custom_stdlib.c"
+      },
+      "bsearch": {
+        "replacement": "my_bsearch",
+        "location": "custom_stdlib.c"
+      }
+    },
+    "stdio.h": {
+      "printf": {
+        "replacement": "my_printf",
+        "location": "custom_stdio.c"
+      },
+      "fgets": {
+        "replacement": "my_fgets",
+        "location": "custom_stdio.c"
+      }
+    },
+    "time.h": {
+      "difftime": {
+        "replacement": "my_difftime",
+        "location": "custom_time.c"
+      },
+      "clock": {
+        "replacement": "my_clock",
+        "location": "custom_time.c"
+      }
+    },
+    "tgmath.h": {
+      "__tg_sqrt": {
+        "replacement": "my_sqrt",
+        "location": "custom_math.c"
+      }
+    }
+  }
+}

package/src/tests/Section21-StandardLibraries/problematic_misra_config.json

@@ -0,0 +1,19 @@
+{
+  "disallowedFunctions": {
+    "stdlib.h": {
+      "malloc": {
+        "replacement": "my_malloc",
+        "location": "custom_stdlib.c"
+      },
+      "calloc": {
+        "replacement": "my_calloc",
+        "location": "custom_stdlib.c"
+      },
+      "realloc": {
+        "replacement": "my_realloc",
+        "location": "custom_stdlib.c"
+      },
+      "free": {}
+    }
+  }
+}