@specs-feup/clava-misra 1.0.0

package/src/misra/tests/S16_SwitchStatements.test.ts

@@ -0,0 +1,164 @@
+import MISRAReporter from "../MISRAReporter.js";
+import S16_SwitchStatementPass from "../passes/S16_SwitchStatementPass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FileJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { expectNumberOfErrors, registerSourceCode, TestFile } from "./utils.js";
+
+const passingMisc = `void f ( void )
+{
+    int x;
+    bool flag;
+    switch ( x )
+{
+case 1:
+case 2: 
+x = 1;
+break;
+default:
+break;
+}
+switch (x) {
+    case 1:
+    case 2:
+    default:
+    break;
+}
+}`;
+
+const failingMisc = `void f ( void )
+{
+    int x;
+    bool flag;
+    switch ( x )
+{
+case 1: /* Compliant */
+if ( flag )
+{
+case 2: /* Non-compliant */
+x = 1;
+}
+break;
+default:
+break;
+case 3:
+break;
+}
+switch (x) {
+    case 1:
+    case 2:
+    break;
+}
+}`;
+
+const passingFormat = `void f ( void )
+{
+    int x, y, z;
+    int flag;
+    switch (x) {
+        case 1:
+            z = y+x;
+            break;
+        case 2:
+            z = y-x;
+            break;
+        default:
+            z = 4;
+            break;
+    }
+    switch (flag) {
+        case 0:
+            x = 2;
+            break;
+        case 1: 
+            x = 4;
+            break;
+        case 2:
+            x = 6;
+            break;
+    }
+    switch (z) {
+        case 1:
+            y = 0;
+            break;
+        case 6:
+        case 42:
+            y = 1;
+            break;
+        case 9139:
+        default:
+            y = 2;
+            break;
+    }
+}`;
+
+const failingFormat = `void f ( void )
+{
+    int x, y, z;
+    bool flag;
+    switch (x) {
+        case 1:
+            z = y+x;
+        case 2:
+            z = y-x;
+            break;
+        default:
+            z = 4;
+    }
+    switch (flag) {
+        case 0:
+            x = 2;
+            break;
+        case 1: 
+            x = 4;
+            break;
+    }
+    switch (z) {
+        case 1:
+        case 6:
+        case 42:
+            y = 1;
+            break;
+        case 9139:
+        default:
+            y = 2;
+            break;
+    }
+}`;
+
+const miscFiles: TestFile[] = [
+    {name: "badmmisc.cpp", code: failingMisc},
+    {name: "goodmisc.cpp", code: passingMisc}
+];
+
+const formatFiles: TestFile[] = [
+    {name: "badformat.cpp", code: failingFormat},
+    {name: "goodformat.cpp", code: passingFormat}
+];
+
+describe("Switch statements: misc", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S16_SwitchStatementPass(true, [2, 4, 5]);
+    registerSourceCode(miscFiles);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "goodmisc.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 3, Query.search(FileJp, {name: "badmisc.cpp"}).first() as Joinpoint);
+    });
+});
+
+describe("Switch statements: format", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S16_SwitchStatementPass(true, [1, 6, 7]);
+    registerSourceCode(formatFiles);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "goodformat.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 5, Query.search(FileJp, {name: "badformat.cpp"}).first() as Joinpoint);
+    });
+});

package/src/misra/tests/S17_Functions.test.ts

@@ -0,0 +1,46 @@
+import MISRAReporter from "../MISRAReporter.js";
+import S17_FunctionPass from "../passes/S17_FunctionPass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FileJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { expectNumberOfErrors, registerSourceCode, TestFile } from "./utils.js";
+
+const passingCode = `int g() {
+    return 5;
+}
+
+int main(int argc, char *argv[]) {
+    (void)g();
+
+    return 0;
+}`;
+
+const failingCode = `#include <stdarg.h>
+
+int f() {
+    return 5;
+}
+
+int test(int argc, char *argv[]) {
+    f();
+
+    return 0;
+}`;
+
+const files: TestFile[] = [
+    {name: "bad.cpp", code: failingCode},
+    {name: "good.cpp", code: passingCode}
+]
+
+describe("Expressions", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S17_FunctionPass(true, [1, 7]);
+    registerSourceCode(files);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "good.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 2, Query.search(FileJp, {name: "bad.cpp"}).first() as Joinpoint);
+    });
+});

package/src/misra/tests/S18_PointersArrays.test.ts

@@ -0,0 +1,167 @@
+import MISRAReporter from "../MISRAReporter.js";
+import S18_PointersArraysPass from "../passes/S18_PointersArraysPass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FileJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { expectNumberOfErrors, registerSourceCode, TestFile } from "./utils.js";
+
+const passingArithmetic = `void fn1 ( void )
+{
+    int a[ 10 ];
+    int *ptr;
+    int index = 0U;
+    index = index + 1U; /* Compliant - rule only applies to pointers */
+    a[ index ] = 0U; /* Compliant */
+    ptr = &a[ 5 ]; /* Compliant */
+    ptr = a;
+    ptr++; /* Compliant - increment operator not + */
+    //*( ptr + 5 ) = 0U; /* Non-compliant */
+    ptr[ 5 ] = 0U; /* Compliant */
+}
+
+void fn3 ( int *p1, int p2[ ] )
+{
+    p1++; /* Compliant */
+    //p1 = p1 + 5; /* Non-compliant */
+    p1[ 5 ] = 0U; /* Compliant */
+    p2++; /* Compliant */
+    //p2 = p2 + 3; /* Non-compliant */
+    p2[ 3 ] = 0U; /* Compliant */
+}`;
+
+const failingArithmetic = `void fn1 ( void )
+{
+    int a[ 10 ];
+    int *ptr;
+    int index = 0U;
+    index = index + 1U; /* Compliant - rule only applies to pointers */
+    a[ index ] = 0U; /* Compliant */
+    ptr = &a[ 5 ]; /* Compliant */
+    ptr = a;
+    ptr++; /* Compliant - increment operator not + */
+    *( ptr + 5 ) = 0U; /* Non-compliant */
+    ptr[ 5 ] = 0U; /* Compliant */
+}
+
+void fn3 ( int *p1, int p2[ ] )
+{
+    p1++; /* Compliant */
+    p1 = p1 + 5; /* Non-compliant */
+    p1[ 5 ] = 0U; /* Compliant */
+    p2++; /* Compliant */
+    p2 = p2 + 3; /* Non-compliant */
+    p2[ 3 ] = 0U; /* Compliant */
+}`;
+
+const passingDepth = ``;
+
+const failingDepth = `typedef int * INTPTR;
+void function ( int ** arrPar[ ] ) /* Non-compliant */
+{
+int ** obj2; /* Compliant */
+int *** obj3; /* Non-compliant */
+INTPTR * obj4; /* Compliant */
+INTPTR * const * const obj5 = 0; /* Non-compliant */
+int ** arr[ 10 ]; /* Compliant */
+int ** ( *parr )[ 10 ]; /* Compliant */
+int * ( **pparr )[ 10 ]; /* Compliant */
+}
+struct s
+{
+int * s1; /* Compliant */
+int ** s2; /* Compliant */
+int *** s3; /* Non-compliant */
+};
+struct s * ps1; /* Compliant */
+struct s ** ps2; /* Compliant */
+struct s *** ps3; /* Non-compliant */
+int ** ( *pfunc1 )( void ); /* Compliant */
+int ** ( **pfunc2 )( void ); /* Compliant */
+int ** ( ***pfunc3 )( void ); /* Non-compliant */
+int *** ( **pfunc4 )( void ); /* Non-compliant */`;
+
+const failingSizes = `struct s
+{
+unsigned short len;
+unsigned int data[ ]; /* Non-compliant - flexible array member */
+} str;
+
+void f ( void )
+{
+    int n = 5;
+    typedef int Vector[ n ]; /* An array type with 5 elements */
+    n = 7;
+    Vector a1; /* An array type with 5 elements */
+    int a2[ n ]; /* An array type with 7 elements */
+}`;
+
+const passingSizes = `struct s
+{
+unsigned short len;
+unsigned int data[ 6 ]; 
+} str;
+
+void f ( void )
+{
+    int n = 5;
+    typedef int Vector[ 5 ]; /* An array type with 5 elements */
+    n = 7;
+    Vector a1; /* An array type with 5 elements */
+    int a2[ 7 ]; /* An array type with 7 elements */
+}`;
+
+const arithmeticFiles: TestFile[] = [
+    {name: "badarithmetic.cpp", code: failingArithmetic},
+    {name: "goodarithmetic.cpp", code: passingArithmetic}
+];
+
+const depthFiles: TestFile[] = [
+    {name: "baddepth.cpp", code: failingDepth},
+    {name: "gooddepth.cpp", code: passingDepth}
+];
+
+const sizeFiles: TestFile[] = [
+    {name: "goodsizes.cpp", code: passingSizes},
+    {name: "badsizes.cpp", code: failingSizes}
+];
+
+describe("Pointers and arrays: arithmetic", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S18_PointersArraysPass(true, [4]);
+    registerSourceCode(arithmeticFiles);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "goodarithmetic.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 3, Query.search(FileJp, {name: "badarithmetic.cpp"}).first() as Joinpoint);
+    });
+});
+
+describe("Pointers and arrays: declaration depth", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S18_PointersArraysPass(true, [5]);
+    registerSourceCode(depthFiles);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "gooddepth.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 7, Query.search(FileJp, {name: "baddepth.cpp"}).first() as Joinpoint);
+    });
+});
+
+describe("Pointers and arrays: variable size", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S18_PointersArraysPass(true, [7,8]);
+    registerSourceCode(sizeFiles);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "goodsizes.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 3, Query.search(FileJp, {name: "badsizes.cpp"}).first() as Joinpoint);
+    });
+});

package/src/misra/tests/S19_OverlappingStorage.test.ts

@@ -0,0 +1,38 @@
+import MISRAReporter from "../MISRAReporter.js";
+import S19_OverlappingStoragePass from "../passes/S19_OverlappingStoragePass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FileJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { expectNumberOfErrors, registerSourceCode, TestFile } from "./utils.js";
+
+const passingCode = `struct a {
+    int a;
+    int b;
+};
+
+int main(int argc, char *argv[]) {
+    return 0;
+}`;
+
+const failingCode = `union a {
+    int a;
+    int b;
+};`;
+
+const files: TestFile[] = [
+    {name: "bad.cpp", code: failingCode},
+    {name: "good.cpp", code: passingCode}
+]
+
+describe("Expressions", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S19_OverlappingStoragePass(true, [2]);
+    registerSourceCode(files);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "good.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 1, Query.search(FileJp, {name: "bad.cpp"}).first() as Joinpoint);
+    });
+});

package/src/misra/tests/S3_Comments.test.ts

@@ -0,0 +1,36 @@
+import MISRAReporter from "../MISRAReporter.js";
+import S3_CommentPass from "../passes/S3_CommentPass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FileJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { expectNumberOfErrors, registerSourceCode, TestFile } from "./utils.js";
+
+const passingCode = `int main(int argc, char *argv[]) {
+    int x, y, z;//good inline comment
+    //good comment
+    return 0;
+}`;
+
+const failingCode = `int test(int argc, char *argv[]) {
+    int x, y, z; //bad inl//ine comment
+    //bad /*comment
+    return 0;
+}`;
+
+const files: TestFile[] = [
+    {name: "bad.cpp", code: failingCode},
+    {name: "good.cpp", code: passingCode}
+]
+
+describe("Expressions", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S3_CommentPass(true, [3]);
+    registerSourceCode(files);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "good.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 2, Query.search(FileJp, {name: "bad.cpp"}).first() as Joinpoint);
+    });
+});

package/src/misra/tests/S6_Types.test.ts

@@ -0,0 +1,36 @@
+import MISRAReporter from "../MISRAReporter.js";
+import S6_TypePass from "../passes/S6_TypePass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FileJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { expectNumberOfErrors, registerSourceCode, TestFile } from "./utils.js";
+
+const passingCode = `struct good {
+    int a:4;
+    int:1;
+    unsigned int b:8;
+};`;
+
+const failingCode = `struct good {
+    int a:4;
+    int c:1;
+    unsigned int b:8;
+};`;
+
+const files: TestFile[] = [
+    {name: "bad.cpp", code: failingCode},
+    {name: "good.cpp", code: passingCode}
+]
+
+describe("Expressions", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S6_TypePass(true, [2]);
+    registerSourceCode(files);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "good.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 1, Query.search(FileJp, {name: "bad.cpp"}).first() as Joinpoint);
+    });
+});

package/src/misra/tests/S7_LiteralsConstants.test.ts

@@ -0,0 +1,48 @@
+import MISRAReporter from "../MISRAReporter.js";
+import S7_LiteralsConstantsPass from "../passes/S7_LiteralsConstantsPass.js";
+import Query from "@specs-feup/lara/api/weaver/Query.js";
+import { FileJp, Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import { expectNumberOfErrors, registerSourceCode, TestFile } from "./utils.js";
+
+const passingCode = `void bar(const char* s) {
+   return;
+}
+
+const char* foo() {
+   const char* s = "hello world";
+   int a = 12;
+   long b = 42L;
+   bar("bad call");
+   return "bye world";
+}`;
+ 
+ const failingCode = `void bar(char* s) {
+   return;
+}
+
+char* foo() {
+   char* s = "hello world";
+   int a = 014;
+   long b = 42l;
+   bar("bad call");
+   return "bye world";
+}`;
+
+const files: TestFile[] = [
+    {name: "bad.cpp", code: failingCode},
+    {name: "good.cpp", code: passingCode}
+]
+
+describe("Expressions", () => {
+    const reporter = new MISRAReporter();
+    const pass = new S7_LiteralsConstantsPass(true, [1, 3, 4]);
+    registerSourceCode(files);
+
+    it("should pass", () => {
+        expectNumberOfErrors(reporter, pass, 0, Query.search(FileJp, {name: "good.cpp"}).first() as Joinpoint);
+    });
+    
+    it("should fail", () => {
+        expectNumberOfErrors(reporter, pass, 5, Query.search(FileJp, {name: "bad.cpp"}).first() as Joinpoint);
+    });
+});

package/src/misra/tests/utils.ts

@@ -0,0 +1,47 @@
+import AggregatePassResult from "@specs-feup/lara/api/lara/pass/results/AggregatePassResult.js";
+import MISRAPassResult from "../MISRAPassResult.js";
+import MISRAReporter from "../MISRAReporter.js";
+import MISRAPass from "../MISRAPass.js";
+import { Joinpoint } from "@specs-feup/clava/api/Joinpoints.js";
+import Clava from "@specs-feup/clava/api/clava/Clava.js";
+import ClavaJoinPoints from "@specs-feup/clava/api/clava/ClavaJoinPoints.js";
+
+function countErrors($passResult: AggregatePassResult): number {
+    let count = 0;
+    $passResult.results.forEach(res => {
+        const misraRes = res as MISRAPassResult;
+        count += misraRes.reports.length;
+    });
+
+    return count;
+}
+
+export function expectNumberOfErrors($reporter: MISRAReporter, $pass: MISRAPass, $errors: number, $jp: Joinpoint) {
+    const result = $reporter.applyPass($pass, $jp);
+    if (!result) {
+        expect($errors).toBe(0);
+        return;
+    }
+    expect(countErrors(result)).toBe($errors);
+}
+
+export interface TestFile {
+    name: string,
+    code: string
+}
+
+export function registerSourceCode(files: TestFile[]): void {
+    beforeAll(() => {
+      Clava.getProgram().push();
+      const program = Clava.getProgram();
+      files.forEach(file => {
+        const sourceFile = ClavaJoinPoints.fileWithSource(file.name, file.code);
+        program.addFile(sourceFile);
+      });
+      program.rebuild();
+    });
+  
+    afterAll(() => {
+      Clava.getProgram().pop();
+    });
+  }

package/tsconfig.jest.json

@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["**/*.spec.ts", "**/*.test.ts"],
+  "exclude": ["node_modules"]
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts"],
+  "compilerOptions": {
+    "outDir": "dist",
+    "target": "ES2022",
+    "module": "NodeNext",
+    "declaration": true,
+    "strict": true,
+    "allowJs": true,
+    "checkJs": true,
+    "moduleResolution": "NodeNext",
+    "sourceMap": true,
+    "declarationMap": true,
+    "allowSyntheticDefaultImports": true
+    //"esModuleInterop": true
+  }
+}

package/typedoc.config.js

@@ -0,0 +1,6 @@
+import { fileURLToPath } from "url";
+
+export default {
+  extends: [ fileURLToPath(import.meta.resolve("lara-js/typedoc.base.json")) ],
+  entryPoints: ["src/"],
+}