@mchp-mcc/scf-pic8-opamp-v2 1.0.0

package/src/PinsLogic.test.ts

@@ -0,0 +1,983 @@
+import { behaviour, direction, pin_row } from "@microchip/pin-standard";
+
+import { AppModel } from "../generated_module/src/types/AutoModuleTypes";
+import { getModel, mockState } from "../generated_module/tests/AppModel.test";
+import { mockAssignedModule } from "../generated_module/tests/processor.test";
+import { getDerivedData } from "./DerivedData";
+import { getRowData } from "./PinsLogic";
+
+const expectedActionsPosPins = [
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.pssOpacon3",
+                    tabId: "main",
+                    value: "OPA2IN0+",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN0+",
+    },
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.pssOpacon3",
+                    tabId: "main",
+                    value: "OPA2IN1+",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN1+",
+    },
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.pssOpacon3",
+                    tabId: "main",
+                    value: "OPA2IN2+",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN2+",
+    },
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.pssOpacon3",
+                    tabId: "main",
+                    value: "OPA2IN3+",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN3+",
+    },
+    {
+        actiontype: "ATTRIBACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "software.cnameAttribforPosPins",
+                    tabId: "main",
+                    value: { attribs: ["cname"] },
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: ".*",
+    },
+    {
+        actiontype: "ATTRIBACTION",
+        state: {
+            UL: {
+                payload: {
+                    path: "software.cnameAttribforPosPins",
+                    tabId: "main",
+                    value: { attribs: ["cname"] },
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: ".*",
+    },
+];
+
+describe("Positive Input IN0 Tests", () => {
+    const mockModule = mockAssignedModule(mockState());
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "posPins",
+        module: "OPA2",
+        function: "OPA2INx+",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\+$",
+        },
+        behaviour: behaviour.SINGLE_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN0+",
+        },
+    };
+
+    it("Test for OPA2IN0+ pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsPosPins);
+    });
+});
+
+describe("Positive Input IN1 Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pchOpacon2: "OPA2IN+",
+                    pssOpacon3: "OPA2IN1+",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "posPins",
+        module: "OPA2",
+        function: "OPA2INx+",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\+$",
+        },
+        behaviour: behaviour.SINGLE_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN1+",
+        },
+    };
+
+    it("Test for OPA2IN1+ pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsPosPins);
+    });
+});
+
+describe("Positive Input IN2 Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pchOpacon2: "OPA2IN+",
+                    pssOpacon3: "OPA2IN2+",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "posPins",
+        module: "OPA2",
+        function: "OPA2INx+",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\+$",
+        },
+        behaviour: behaviour.SINGLE_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN2+",
+        },
+    };
+
+    it("Test for OPA2IN2+ pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsPosPins);
+    });
+});
+
+describe("Positive Input IN3 Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pchOpacon2: "OPA2IN+",
+                    pssOpacon3: "OPA2IN3+",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "posPins",
+        module: "OPA2",
+        function: "OPA2INx+",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\+$",
+        },
+        behaviour: behaviour.SINGLE_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN3+",
+        },
+    };
+
+    it("Test for OPA2IN3+ pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsPosPins);
+    });
+});
+
+describe("Positive Input GSEL Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pchOpacon2: "GSEL",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "posPins",
+        module: "OPA2",
+        function: "OPA2INx+",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\+$",
+        },
+        behaviour: behaviour.SINGLE_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN1+",
+        },
+    };
+
+    it("Test for hiding OPA2INx+ row", () => {
+        expect(getRowData(model, rowData)).toBeUndefined();
+        expect(getRowData(model, rowData)?.actions).toBeUndefined();
+    });
+});
+
+const expectedActionsNegPins = [
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.nssOpacon1",
+                    tabId: "main",
+                    value: "OPA2IN0-",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN0-",
+    },
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.nssOpacon1",
+                    tabId: "main",
+                    value: "OPA2IN1-",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN1-",
+    },
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.nssOpacon1",
+                    tabId: "main",
+                    value: "OPA2IN2-",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN2-",
+    },
+    {
+        actiontype: "SETACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "channelSel.nssOpacon1",
+                    tabId: "main",
+                    value: "OPA2IN3-",
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: "OPA2IN3-",
+    },
+    {
+        actiontype: "SETACTION",
+        state: {
+            UL: {
+                payload: { path: "channelSel.nssOpacon1", tabId: "main", value: "Vss" },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: ".*",
+    },
+    {
+        actiontype: "ATTRIBACTION",
+        state: {
+            L: {
+                payload: {
+                    path: "software.cnameAttribforNegPins",
+                    tabId: "main",
+                    value: { attribs: ["cname"] },
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: ".*",
+    },
+    {
+        actiontype: "ATTRIBACTION",
+        state: {
+            UL: {
+                payload: {
+                    path: "software.cnameAttribforNegPins",
+                    tabId: "main",
+                    value: { attribs: ["cname"] },
+                },
+                type: "[FORM] SUBMIT",
+            },
+        },
+        validFor: ".*",
+    },
+];
+
+describe("Negative Input IN0 Tests", () => {
+    const mockModule = mockAssignedModule(mockState());
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN0-",
+        },
+    };
+
+    it("Test for OPA2IN0- pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsNegPins);
+    });
+});
+
+describe("Negative Input IN1 Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    nchOpacon2: "OPA2IN-",
+                    nssOpacon1: "OPA2IN1-",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN1-",
+        },
+    };
+
+    it("Test for OPA2IN1- pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsNegPins);
+    });
+});
+
+describe("Negative Input IN2 Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    nchOpacon2: "OPA2IN-",
+                    nssOpacon1: "OPA2IN2-",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN2-",
+        },
+    };
+
+    it("Test for OPA2IN2- pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsNegPins);
+    });
+});
+
+describe("Negative Input IN3 Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    nchOpacon2: "OPA2IN-",
+                    nssOpacon1: "OPA2IN3-",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN3-",
+        },
+    };
+
+    it("Test for OPA2IN3- pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsNegPins);
+    });
+});
+
+describe("Negative Input Vss Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    nchOpacon2: "OPA2IN-",
+                    nssOpacon1: "Vss",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "^.{0}$",
+        },
+    };
+
+    it("Test for Vss pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsNegPins);
+    });
+});
+
+describe("OPA2PPS Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                overrideSel: {
+                    orsOpaors: "OPAxORPPS",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "ppsPin",
+        module: "OPA2",
+        function: "OPA2ORPPS",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "^OPA\\dOR$",
+        },
+        behaviour: behaviour.PPS,
+    };
+
+    it("Test for OPA2PPS pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+    });
+});
+
+describe("OPA2OUT Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    intoeOpacon3: false,
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "outputPin",
+        module: "OPA2",
+        function: "OPA2OUT",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "^OPA\\dOUT$",
+        },
+        behaviour: behaviour.ALWAYS_LOCKED,
+    };
+
+    it("Test for OPA2OUT pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+    });
+});
+
+describe("Override test with LFINTOSC", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                overrideSel: {
+                    orsOpaors: "LFINTOSC",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "ppsPin",
+        module: "OPA2",
+        function: "OPA2ORPPS",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "^OPA\\dOR$",
+        },
+        behaviour: behaviour.PPS,
+    };
+
+    it("Test for hiding OPA2ORPPS row", () => {
+        expect(getRowData(model, rowData)).toBeUndefined();
+    });
+});
+
+describe("Negative Input for Inverting PGA Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Inverting Programmable Gain Amplifier",
+                },
+                channelSel: {
+                    nchOpacon2: "GSEL",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN0-",
+        },
+    };
+
+    it("Test for GSEL pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsNegPins);
+    });
+});
+
+describe("Negative Input GSEL Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    nchOpacon2: "GSEL",
+                },
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "^.{0}$",
+        },
+    };
+
+    it("Test for hiding OPA2INx- row", () => {
+        expect(getRowData(model, rowData)).toBeUndefined();
+        expect(getRowData(model, rowData)?.actions).toBeUndefined();
+    });
+});
+
+describe("Positive Input Tests with pin-standard", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pchOpacon2: "OPA2IN+",
+                    pssOpacon3: "OPA2IN0+",
+                },
+            },
+        },
+        imports: {
+            ...mockModule.imports,
+            pin_standard: {
+                interfaceId: {
+                    name: "pin-standard",
+                    version: "^0",
+                },
+                handle: {
+                    exportId: "mockExportId",
+                    providerId: "mockProviderId",
+                },
+                payload: {
+                    allpins: {
+                        RA0: {
+                            OPA2: {
+                                "OPA2IN3+": {
+                                    alias: "OPA2IN3+",
+                                },
+                                "OPA2IN3-": {
+                                    alias: "OPA2IN3-",
+                                },
+                            },
+                        },
+                        RA2: {
+                            OPA2: {
+                                "OPA2IN2+": {
+                                    alias: "OPA2IN2+",
+                                },
+                                "OPA2IN2-": {
+                                    alias: "OPA2IN2-",
+                                },
+                            },
+                        },
+                        RB4: {
+                            OPA2: {
+                                "OPA2IN0-": {
+                                    alias: "OPA2IN0-",
+                                },
+                            },
+                        },
+                        RB5: {
+                            OPA2: {
+                                "OPA2IN0+": {
+                                    alias: "OPA2IN0+",
+                                },
+                            },
+                        },
+                        RC2: {
+                            OPA2: {
+                                OPA2OUT: {
+                                    alias: "OPA2OUT",
+                                },
+                            },
+                        },
+                        RC3: {
+                            OPA2: {
+                                "OPA2IN1-": {
+                                    alias: "OPA2IN1-",
+                                },
+                                "OPA2IN1+": {
+                                    alias: "OPA2IN1+",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "posPins",
+        module: "OPA2",
+        function: "OPA2INx+",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\+$",
+        },
+        behaviour: behaviour.SINGLE_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN0+",
+        },
+        attribs: [
+            { aliasReEx: "OPA2IN3+", cname: "RA0_IN3" },
+            { aliasReEx: "OPA2IN2+", cname: "RA2_IN2" },
+            { aliasReEx: "OPA2IN0+", cname: "RB5_IN0" },
+            { aliasReEx: "OPA2IN1+", cname: "RC3_IN1" },
+        ],
+    };
+
+    it("Test for OPA2IN0+ pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsPosPins);
+    });
+});
+
+describe("Negative Input Tests with pin-standard", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    nchOpacon2: "OPA2IN-",
+                    nssOpacon1: "OPA2IN0-",
+                },
+            },
+        },
+        imports: {
+            ...mockModule.imports,
+            pin_standard: {
+                interfaceId: {
+                    name: "pin-standard",
+                    version: "^0",
+                },
+                handle: {
+                    exportId: "mockExportId",
+                    providerId: "mockProviderId",
+                },
+                payload: {
+                    allpins: {
+                        RA0: {
+                            OPA2: {
+                                "OPA2IN3+": {
+                                    alias: "OPA2IN3+",
+                                },
+                                "OPA2IN3-": {
+                                    alias: "OPA2IN3-",
+                                },
+                            },
+                        },
+                        RA2: {
+                            OPA2: {
+                                "OPA2IN2+": {
+                                    alias: "OPA2IN2+",
+                                },
+                                "OPA2IN2-": {
+                                    alias: "OPA2IN2-",
+                                },
+                            },
+                        },
+                        RB4: {
+                            OPA2: {
+                                "OPA2IN0-": {
+                                    alias: "OPA2IN0-",
+                                },
+                            },
+                        },
+                        RB5: {
+                            OPA2: {
+                                "OPA2IN0+": {
+                                    alias: "OPA2IN0+",
+                                },
+                            },
+                        },
+                        RC2: {
+                            OPA2: {
+                                OPA2OUT: {
+                                    alias: "OPA2OUT",
+                                },
+                            },
+                        },
+                        RC3: {
+                            OPA2: {
+                                "OPA2IN1-": {
+                                    alias: "OPA2IN1-",
+                                },
+                                "OPA2IN1+": {
+                                    alias: "OPA2IN1+",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN0-",
+        },
+        attribs: [
+            { aliasReEx: "OPA2IN3-", cname: "RA0_IN3" },
+            { aliasReEx: "OPA2IN2-", cname: "RA2_IN2" },
+            { aliasReEx: "OPA2IN0-", cname: "RB4_IN0" },
+            { aliasReEx: "OPA2IN1-", cname: "RC3_IN1" },
+        ],
+    };
+
+    it("Test for OPA2IN0- pin data", () => {
+        expect(getRowData(model, rowData)).toMatchObject(rowData);
+        expect(getRowData(model, rowData)?.actions).toEqual(expectedActionsNegPins);
+    });
+});
+
+describe("Undefined pin-standard test", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        imports: {
+            ...mockModule.imports,
+            pin_standard: {
+                interfaceId: {
+                    name: "pin-standard",
+                    version: "^0",
+                },
+                payload: undefined,
+            },
+            scf_pic8_opamp_v2: {
+                interfaceId: {
+                    name: "scf-pic8-opamp-v2",
+                    version: "^1.0.0",
+                },
+                handle: {
+                    exportId: "mockExportId",
+                    providerId: "mockProviderId",
+                },
+                payload: undefined,
+            },
+        },
+    };
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const rowData: pin_row = {
+        name: "negPins",
+        module: "OPA2",
+        function: "OPA2INx-",
+        direction: direction.input,
+        filter: {
+            module: "OPA2",
+            aliasReEx: "OPA\\dIN\\d\\-$",
+        },
+        behaviour: behaviour.OPTIONAL_PIN_MUX,
+        behaviourMeta: {
+            lockPinRegEx: "OPA2IN0-",
+        },
+    };
+
+    it("Test for undefined pins data", () => {
+        expect(getRowData(model, rowData)).toBeUndefined();
+        expect(getRowData(model, rowData)?.actions).toBeUndefined();
+    });
+});