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

package/src/DerivedData.test.tsx

@@ -0,0 +1,1601 @@
+import { DerivedData } from "@microchip/melody-automodule-interface/lib/src/DerivedData";
+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 { EmptyDerivedData, getDerivedData } from "./DerivedData";
+import { getGeneratorModel } from "./GeneratorModel";
+
+describe("EmptyDerivedData Tests", () => {
+    it("Test for new EmptyDerivedData", () => {
+        expect(new EmptyDerivedData().getMyFunctions()).toStrictEqual({});
+        expect(new EmptyDerivedData().getModel()).toBeUndefined();
+    });
+});
+
+describe("Template Data Tests", () => {
+    const mockModule = mockAssignedModule(mockState());
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const templateData = {
+        componentName: "OPA2",
+        header: { name: "opa2.h", path: "../" },
+        moduleInstance: "OPA2",
+        moduleNameLowerCase: "opa2",
+        moduleNameUpperCase: "OPA2",
+    };
+    expect(derivedFunctions.templateData?.()?.header).toEqual(templateData.header);
+    expect(derivedFunctions.templateData?.()?.moduleInstance).toEqual(
+        templateData.moduleInstance,
+    );
+    expect(derivedFunctions.templateData?.()?.moduleNameLowerCase).toEqual(
+        templateData.moduleNameLowerCase,
+    );
+    expect(derivedFunctions.templateData?.()?.moduleNameUpperCase).toEqual(
+        templateData.moduleNameUpperCase,
+    );
+});
+
+describe("Positive Sources Enumeration Tests", () => {
+    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);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const templateData = {
+        posSources: [
+            { name: "RB5_IN0_pos", value: "0x0" },
+            { name: "RC3_IN1_pos", value: "0x1" },
+            { name: "RA2_IN2_pos", value: "0x2" },
+            { name: "RA0_IN3_pos", value: "0x3" },
+        ],
+    };
+
+    expect(derivedFunctions.templateData?.()?.posSources).toEqual(
+        templateData.posSources,
+    );
+});
+
+describe("Positive Sources Custom Name Enumeration Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                software: {
+                    cnameAttribforPosPins: '{ "RB5": { "cname": "RB5_IN0_c" } }',
+                },
+                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);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const templateData = {
+        posSources: [
+            { name: "RB5_IN0_c_pos", value: "0x0" },
+            { name: "RC3_IN1_pos", value: "0x1" },
+            { name: "RA2_IN2_pos", value: "0x2" },
+            { name: "RA0_IN3_pos", value: "0x3" },
+        ],
+    };
+
+    expect(derivedFunctions.templateData?.()?.posSources).toEqual(
+        templateData.posSources,
+    );
+});
+
+describe("Negative Sources Enumeration Tests", () => {
+    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);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const templateData = {
+        negSources: [
+            { name: "RB4_IN0_neg", value: "0x0" },
+            { name: "RC3_IN1_neg", value: "0x1" },
+            { name: "RA2_IN2_neg", value: "0x2" },
+            { name: "RA0_IN3_neg", value: "0x3" },
+            { name: "Vss", value: "0x7" },
+        ],
+    };
+
+    expect(derivedFunctions.templateData?.()?.negSources).toEqual(
+        templateData.negSources,
+    );
+});
+
+describe("Negative Sources Custom Name Enumeration Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                software: {
+                    cnameAttribforNegPins: '{ "RB4": { "cname": "RB4_IN0_c" } }',
+                },
+                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);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const templateData = {
+        negSources: [
+            { name: "RB4_IN0_c_neg", value: "0x0" },
+            { name: "RC3_IN1_neg", value: "0x1" },
+            { name: "RA2_IN2_neg", value: "0x2" },
+            { name: "RA0_IN3_neg", value: "0x3" },
+            { name: "Vss", value: "0x7" },
+        ],
+    };
+
+    expect(derivedFunctions.templateData?.()?.negSources).toEqual(
+        templateData.negSources,
+    );
+});
+
+describe("Enumeration Tests with undefined hardware", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        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+",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            scf_pic8_opamp_v2: {
+                interfaceId: {
+                    name: "scf-pic8-opamp-v2",
+                    version: "^1.0.0",
+                },
+                handle: undefined,
+                payload: undefined,
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    expect(derivedFunctions.templateData?.()?.posSources).toEqual([]);
+    expect(derivedFunctions.templateData?.()?.negSources).toEqual([]);
+});
+
+describe("GeneratorModel Test", () => {
+    const mockModule = mockAssignedModule(mockState());
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const templateData = {
+        componentName: "OPA2",
+        header: [{ name: "opa2.h", path: "../" }],
+        moduleInstance: "OPA2",
+        moduleNameLowerCase: "opa2",
+        moduleNameUpperCase: "OPA2",
+        negSources: [
+            { name: "RB4_IN0_neg", value: "0x0" },
+            { name: "RC3_IN1_neg", value: "0x1" },
+            { name: "RA2_IN2_neg", value: "0x2" },
+            { name: "RA0_IN3_neg", value: "0x3" },
+            { name: "Vss", value: "0x7" },
+        ],
+        posSources: [
+            { name: "RB5_IN0_pos", value: "0x0" },
+            { name: "RC3_IN1_pos", value: "0x1" },
+            { name: "RA2_IN2_pos", value: "0x2" },
+            { name: "RA0_IN3_pos", value: "0x3" },
+        ],
+    };
+
+    const posSourceModel = [
+        { customName: "RB5_IN0", source: "OPA2IN0+" },
+        { customName: "RC3_IN1", source: "OPA2IN1+" },
+        { customName: "RA2_IN2", source: "OPA2IN2+" },
+        { customName: "RA0_IN3", source: "OPA2IN3+" },
+    ];
+
+    const negSourceModel = [
+        { customName: "RB4_IN0", source: "OPA2IN0-" },
+        { customName: "RC3_IN1", source: "OPA2IN1-" },
+        { customName: "RA2_IN2", source: "OPA2IN2-" },
+        { customName: "RA0_IN3", source: "OPA2IN3-" },
+        { customName: "Vss", source: "Vss" },
+    ];
+
+    it("Test for GeneratorModel", () => {
+        expect(
+            getGeneratorModel?.(
+                model,
+                posSourceModel,
+                negSourceModel,
+                templateData.header,
+            ).posSources,
+        ).toEqual(templateData.posSources);
+        expect(
+            getGeneratorModel?.(
+                model,
+                posSourceModel,
+                negSourceModel,
+                templateData.header,
+            ).negSources,
+        ).toEqual(templateData.negSources);
+    });
+});
+
+describe("Template Data Test with Undefined Hardware", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        imports: {
+            ...mockModule.imports,
+            scf_pic8_opamp_v2: {
+                interfaceId: {
+                    name: "scf-pic8-opamp-v2",
+                    version: "1.0.0",
+                },
+                handle: undefined,
+                payload: undefined,
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData) as AppModel;
+
+    const templateData = {
+        componentName: "OPA",
+        header: [{ name: "opa2.h", path: "../" }],
+        moduleInstance: "OPA",
+        moduleNameLowerCase: "OPA",
+        moduleNameUpperCase: "OPA",
+        negSources: [],
+        posSources: [],
+    };
+
+    const posSourceModel = [
+        { customName: "RB5_IN0", source: "OPA2IN0+" },
+        { customName: "RC3_IN1", source: "OPA2IN1+" },
+        { customName: "RA2_IN2", source: "OPA2IN2+" },
+        { customName: "RA0_IN3", source: "OPA2IN3+" },
+    ];
+
+    const negSourceModel = [
+        { customName: "RB4_IN0", source: "OPA2IN0-" },
+        { customName: "RC3_IN1", source: "OPA2IN1-" },
+        { customName: "RA2_IN2", source: "OPA2IN2-" },
+        { customName: "RA0_IN3", source: "OPA2IN3-" },
+        { customName: "Vss", source: "Vss" },
+    ];
+
+    it("Test for GeneratorModel", () => {
+        expect(
+            getGeneratorModel?.(
+                model,
+                posSourceModel,
+                negSourceModel,
+                templateData.header,
+            ).posSources,
+        ).toEqual(templateData.posSources);
+        expect(
+            getGeneratorModel?.(
+                model,
+                posSourceModel,
+                negSourceModel,
+                templateData.header,
+            ).negSources,
+        ).toEqual(templateData.negSources);
+    });
+});
+
+describe("opa Export Interface Tests", () => {
+    const mockModule = mockAssignedModule(mockState());
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const export_interface = {
+        moduleName: "OPA2",
+        customName: "OPA",
+        hasInterrupts: false,
+    };
+
+    it("Test for opa Export", () => {
+        expect(derivedFunctions?.["opa-output-parameters_payload"]?.()).toEqual(
+            export_interface,
+        );
+    });
+});
+
+describe("DAC Notification Test", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pchOpacon2: "DAC1_OUT",
+                    nchOpacon2: "DAC2_OUT",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for DAC Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text:
+                    "OPA2 uses DAC1 as Positive Channel. Ensure DAC1 has been configured.",
+                type: "warning",
+            },
+            {
+                text:
+                    "OPA2 uses DAC2 as Negative Channel. Ensure DAC2 has been configured.",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("TMR1 Notification Test", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    nssOpacon1: "OPA2IN1-",
+                },
+                overrideSel: {
+                    orsOpaors: "TMR1_OUT",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for TMR1 Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text:
+                    "Ensure that the module selected as Hardware Override Source is configured.",
+                type: "hint",
+            },
+        ]);
+    });
+});
+
+describe("Notification Test with undefined component values", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pssOpacon3: undefined,
+                    nssOpacon1: undefined,
+                    pchOpacon2: undefined,
+                    nchOpacon2: undefined,
+                },
+                overrideSel: {
+                    orenOpahwc: undefined,
+                    orsOpaors: undefined,
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text: "Both the Positive and Negative Sources are mapped to the same pin",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("Calculations Test", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                feedbackSel: {
+                    gselOpacon1: "R1 = 15R and R2 = 1R, R2/R1 = 0.07",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for nonInvGain", () => {
+        expect(derivedFunctions.nonInvGain?.()).toEqual("1.07");
+    });
+
+    it("Test for invGain", () => {
+        expect(derivedFunctions.invGain?.()).toEqual("1.07(Vref/Vin) - 0.07");
+    });
+});
+
+describe("Override Default Value Test for Direct Connection to Pins", () => {
+    const mockModule = mockAssignedModule(mockState());
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const image =
+        "data:image/png;base64,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";
+
+    it("Test for schematic", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("schematic")).toEqual(image);
+    });
+    it("Test for mindiLink", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("mindiLink")).toEqual(
+            "https://kits.microchip.com/redirect/4/PIC18Q71-00",
+        );
+    });
+    it("Test for pchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pchOpacon2")).toEqual("OPA2IN+");
+    });
+    it("Test for pssOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pssOpacon3")).toEqual(
+            "OPA2IN0+",
+        );
+    });
+    it("Test for nchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nchOpacon2")).toEqual("OPA2IN-");
+    });
+    it("Test for nssOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nssOpacon1")).toEqual(
+            "OPA2IN0-",
+        );
+    });
+    it("Test for resonOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("resonOpacon1")).toEqual(
+            "Disabled",
+        );
+    });
+    it("Test for gselOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("gselOpacon1")).toEqual(
+            "R1 = 15R and R2 = 1R, R2/R1 = 0.07",
+        );
+    });
+    it("Test for fmsOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("fmsOpacon3")).toEqual(
+            "No Connection",
+        );
+    });
+    it("Test for ugOpacon0", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("ugOpacon0")).toEqual(
+            "OPAIN- pin",
+        );
+    });
+});
+
+describe("Override Default Value Test for Unity Gain Buffer", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Unity Gain Buffer",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const image =
+        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAATAAAABeBAMAAABWXFVeAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAqUExURf///z09PQICAqqqqtTU1CUlJVlZWefn5xISEomJiZubm729vfb29nV1dR8w18cAAASySURBVGje7dnvSxtnAAfwb5ZLziQXSKpxlbYv4qxaQiFdqHPK4LShMjbBNkSs7sVFR9yUA+mcrmO+sFWJq4VoyzCuL651dk4txLSuP8IgnYjaTVDnHGP6v+y5xGgyY7W1xmflvkSRPLnkk+f3PQJKlChRokSJEiV0hXW2z0ZohKly5fh8brfZbM72ekVx/e/A0NiwozT80FlR0f7NocFWnM5w2OEYGwsE1tdFr9dLgBZ3je9qbjybajGtMP+ORVx7a2ui2muhBBZNYv8boQkGBabAFJgCe4NgxbTCRpUa+5/AuAZKYWxuFqUwW30jnbA85sganTCoa/x0wjDfbacThg4rTycM5/Nb6IRh6nSEThjOfkspjBusoxMGtj6LAtgfDjnD5KckD62t0f7FHGk8fJgvmkL5l40zm6Xos4aatcOGJWSzKUn03RKdMCxYg9te8JgGGNryty0B71IBQ9m2iTZEBwxneyN0wjDqorIpyRPLx+isMTDJe+1k2EjhGizuHBiPA2oBCxcvQcOjaMbtrj5wGAxJe+0kmLGO9aDWOWWfywTuCvDwZcJbPO4w57oqDh6WvNfehFWS2fcyjxm7C0bhzBnoTwiGPrBdMgyGKqQBlrTXjsO4tadkzJJKE1x45s+c4zm9oDMBn6cThrZCN0m3OzETRhABdILb0jnbp12EXjAKgJhOGLd8YozkpiMhJf6F6PqkXbzkjBhP1vQhVmM5GTy+SxOMG61N8crAX8CcHV8FyUSnea+9lsDIxUyBxg4xTbCp3lQ3AKw8YHsfVIPApoB+AsPg+KhfV/ukKz2wsp1vmVCZbccKMEa6YYvBD4OnGSjK5sEsHjys7QU3mYc58893Bl/93b5wlG7W9kPS8glf0RAI4qPtV0xH9gjT+6R9fM2Q+eip+N+iQVBtvRd71NsZ6d9+RfkeYan3/XuHRTAQr7Lf9SZu61NVx/Hl4qvDmF0Oy/YAK+c7soPcUhNulvUYwwLO416OXNICtdR/JxPznka22eNXD2UHUZQTicF+41PCIltbnizsF3Z3tueJTdtcbBc76lQ/5mHV6JokQ/ZPuXigYZn3hC2staRX1/NBge7apBCD/fN9KhgjxCfWQdc+h1LI6zmlq8KSao3hRb1JJYnc9V+DTAGwJBcPIsN+CyHWBq+uD9cy7GxeFMZI2hLH8NZjiCw7P+Xh6bGW+LZ6v2M8FBjitQKKDb4GEJhGeqyuKjebbRs11g+N9NxzlS3AKlnNXJfN5nc2YCpzYi7I/6K3cavVsb3E5I4nPi/TlJBhmP5sMVpjGT/7y0vDj2J9zCTDLLdCm7Dx8KNYU66kbkoTdjkjeymY/hN4tEFdlaiv0kjG+pY5O/M2MCOQB4GRXjcwuwHLkNisGGw6ZefnojNqhzWI1wLjLty/bqwd8YuG088kxgpd7wjpxEz3upvMY5qJnvcvtm/A1DdGTLtOF89fdA6753wYXTtEHvcaUIr7X/MYB35pkj/8ijiBc9DzlU3zH9/GA8aOH+SSK7vA1DW3QVdisF3O+g8NxtZ/Chph3H/ucamBpdxJUwCbuhGhElb2GibWg4BZ83lQCTsZBJ3hoUSJEiVKlLxp+RcOfYAxQu3JIwAAAABJRU5ErkJggg==";
+
+    it("Test for schematic", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("schematic")).toEqual(image);
+    });
+    it("Test for mindiLink", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("mindiLink")).toEqual(
+            "https://kits.microchip.com/redirect/4/PIC18Q71-01",
+        );
+    });
+    it("Test for pchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pchOpacon2")).toEqual("OPA2IN+");
+    });
+    it("Test for pssOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pssOpacon3")).toEqual(
+            "OPA2IN0+",
+        );
+    });
+    it("Test for nchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nchOpacon2")).toEqual(
+            "No Connection",
+        );
+    });
+    it("Test for nssOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nssOpacon1")).toEqual(
+            "OPA2IN0-",
+        );
+    });
+    it("Test for resonOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("resonOpacon1")).toEqual(
+            "Disabled",
+        );
+    });
+    it("Test for gselOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("gselOpacon1")).toEqual(
+            "R1 = 15R and R2 = 1R, R2/R1 = 0.07",
+        );
+    });
+    it("Test for fmsOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("fmsOpacon3")).toEqual(
+            "No Connection",
+        );
+    });
+    it("Test for ugOpacon0", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("ugOpacon0")).toEqual(
+            "OPA Output",
+        );
+    });
+});
+
+describe("Override Default Value Test for Non-Inverting Programmable Gain Amplifier", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Non-Inverting Programmable Gain Amplifier",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const image =
+        "data:image/png;base64,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";
+
+    it("Test for schematic", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("schematic")).toEqual(image);
+    });
+    it("Test for mindiLink", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("mindiLink")).toEqual(
+            "https://kits.microchip.com/redirect/4/PIC18Q71-02",
+        );
+    });
+    it("Test for pchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pchOpacon2")).toEqual("OPA2IN+");
+    });
+    it("Test for pssOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pssOpacon3")).toEqual(
+            "OPA2IN0+",
+        );
+    });
+    it("Test for nchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nchOpacon2")).toEqual("GSEL");
+    });
+    it("Test for nssOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nssOpacon1")).toEqual("Vss");
+    });
+    it("Test for resonOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("resonOpacon1")).toEqual(
+            "Enabled",
+        );
+    });
+    it("Test for gselOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("gselOpacon1")).toEqual(
+            "R1 = 15R and R2 = 1R, R2/R1 = 0.07",
+        );
+    });
+    it("Test for fmsOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("fmsOpacon3")).toEqual("OPA2OUT");
+    });
+    it("Test for ugOpacon0", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("ugOpacon0")).toEqual(
+            "OPAIN- pin",
+        );
+    });
+});
+
+describe("Override Default Value Test for Inverting Programmable Gain Amplifier", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Inverting Programmable Gain Amplifier",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const image =
+        "data:image/png;base64,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";
+
+    it("Test for schematic", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("schematic")).toEqual(image);
+    });
+    it("Test for mindiLink", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("mindiLink")).toEqual(
+            "https://kits.microchip.com/redirect/4/PIC18Q71-03",
+        );
+    });
+    it("Test for pchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pchOpacon2")).toEqual("Vdd/2");
+    });
+    it("Test for pssOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pssOpacon3")).toEqual(
+            "OPA2IN0+",
+        );
+    });
+    it("Test for nchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nchOpacon2")).toEqual("GSEL");
+    });
+    it("Test for nssOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nssOpacon1")).toEqual(
+            "OPA2IN0-",
+        );
+    });
+    it("Test for resonOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("resonOpacon1")).toEqual(
+            "Enabled",
+        );
+    });
+    it("Test for gselOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("gselOpacon1")).toEqual(
+            "R1 = 15R and R2 = 1R, R2/R1 = 0.07",
+        );
+    });
+    it("Test for fmsOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("fmsOpacon3")).toEqual("OPA2OUT");
+    });
+    it("Test for ugOpacon0", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("ugOpacon0")).toEqual(
+            "OPAIN- pin",
+        );
+    });
+});
+
+describe("Override Default Value Test for Custom Configuration", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Custom Configuration",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const image =
+        "data:image/png;base64,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";
+
+    it("Test for schematic", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("schematic")).toEqual(image);
+    });
+    it("Test for mindiLink", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("mindiLink")).toEqual(
+            "https://kits.microchip.com/redirect/4/PIC18Q71-00",
+        );
+    });
+    it("Test for pchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pchOpacon2")).toEqual("Vss");
+    });
+    it("Test for pssOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("pssOpacon3")).toEqual(
+            "OPA2IN0+",
+        );
+    });
+    it("Test for nchOpacon2", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nchOpacon2")).toEqual(
+            "No Connection",
+        );
+    });
+    it("Test for nssOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("nssOpacon1")).toEqual(
+            "OPA2IN0-",
+        );
+    });
+    it("Test for resonOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("resonOpacon1")).toEqual(
+            "Disabled",
+        );
+    });
+    it("Test for gselOpacon1", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("gselOpacon1")).toEqual(
+            "R1 = 15R and R2 = 1R, R2/R1 = 0.07",
+        );
+    });
+    it("Test for fmsOpacon3", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("fmsOpacon3")).toEqual(
+            "No Connection",
+        );
+    });
+    it("Test for ugOpacon0", () => {
+        expect(derivedFunctions.overrideDefaultValues?.("ugOpacon0")).toEqual(
+            "OPAIN- pin",
+        );
+    });
+});
+
+describe("Notification Test for Direct Connection to Pins 1", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pchOpacon2: "GSEL",
+                    pssOpacon3: "OPA2IN1+",
+                    nchOpacon2: "GSEL",
+                    nssOpacon1: "OPA2IN1-",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text: "Invalid selection for Positive Channel in this configuration",
+                type: "warning",
+            },
+            {
+                text: "Invalid selection for Negative Channel in this configuration",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("Notification Test for Direct Connection to Pins 2", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pssOpacon3: "OPA2IN1+",
+                    nssOpacon1: "OPA2IN1-",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text: "Both the Positive and Negative Sources are mapped to the same pin",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("Notification Test for Direct Connection to Pins 3", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                channelSel: {
+                    pssOpacon3: "OPA2IN1+",
+                    nssOpacon1: "OPA2IN0-",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([]);
+    });
+});
+
+describe("Notification Test for Unity Gain Buffer 1", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Unity Gain Buffer",
+                },
+                channelSel: {
+                    pchOpacon2: "GSEL",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text: "Invalid selection for Positive Channel in this configuration",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("Notification Test for Unity Gain Buffer 2", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Unity Gain Buffer",
+                },
+                channelSel: {
+                    pchOpacon2: "OPA2IN+",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([]);
+    });
+});
+
+describe("Notification Test for Non-Inverting Programmable Gain Amplifier 1", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Non-Inverting Programmable Gain Amplifier",
+                },
+                channelSel: {
+                    pchOpacon2: "GSEL",
+                    nchOpacon2: "OPA2IN-",
+                    nssOpacon1: "OPA2IN0-",
+                },
+                feedbackSel: {
+                    fmsOpacon3: "No Connection",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text: "Invalid selection for Positive Channel in this configuration",
+                type: "warning",
+            },
+            {
+                text: "Invalid selection for Negative Channel in this configuration",
+                type: "warning",
+            },
+            {
+                text: "Invalid selection for Negative Source in this configuration",
+                type: "warning",
+            },
+            {
+                text:
+                    "Invalid selection for Feedback Mode Selection in this configuration",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("Notification Test for Non-Inverting Programmable Gain Amplifier 2", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Non-Inverting Programmable Gain Amplifier",
+                },
+                channelSel: {
+                    pchOpacon2: "OPA2IN+",
+                    nchOpacon2: "GSEL",
+                    nssOpacon1: "Vss",
+                },
+                feedbackSel: {
+                    fmsOpacon3: "OPA2OUT",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([]);
+    });
+});
+
+describe("Notification Test for Inverting Programmable Gain Amplifier 1", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Inverting Programmable Gain Amplifier",
+                },
+                channelSel: {
+                    pchOpacon2: "GSEL",
+                    nchOpacon2: "OPA2IN-",
+                },
+                feedbackSel: {
+                    fmsOpacon3: "No Connection",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text: "Invalid selection for Positive Channel in this configuration",
+                type: "warning",
+            },
+            {
+                text: "Invalid selection for Negative Channel in this configuration",
+                type: "warning",
+            },
+            {
+                text:
+                    "Invalid selection for Feedback Mode Selection in this configuration",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("Notification Test for Inverting Programmable Gain Amplifier 2", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Inverting Programmable Gain Amplifier",
+                },
+                channelSel: {
+                    pchOpacon2: "Vss",
+                    nchOpacon2: "OPA2IN-",
+                },
+                feedbackSel: {
+                    fmsOpacon3: "No Connection",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([
+            {
+                text: "Invalid selection for Positive Channel in this configuration",
+                type: "warning",
+            },
+            {
+                text: "Invalid selection for Negative Channel in this configuration",
+                type: "warning",
+            },
+            {
+                text:
+                    "Invalid selection for Feedback Mode Selection in this configuration",
+                type: "warning",
+            },
+        ]);
+    });
+});
+
+describe("Notification Test for Inverting Programmable Gain Amplifier 3", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Inverting Programmable Gain Amplifier",
+                },
+                channelSel: {
+                    pchOpacon2: "OPA2IN+",
+                    nchOpacon2: "GSEL",
+                },
+                feedbackSel: {
+                    fmsOpacon3: "OPA2OUT",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for Invalid Notifications", () => {
+        expect(derivedFunctions?.alerts?.()).toEqual([]);
+    });
+});
+
+describe("Import Interface Tests", () => {
+    const mockModule = mockAssignedModule(mockState());
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const initializer_system_results = {
+        initializer: {
+            name: "OPA2_Initialize",
+            header: {
+                name: "opa2.h",
+                path: "opa/",
+            },
+        },
+    };
+
+    it("Test for system interface", () => {
+        expect(derivedFunctions?.initializer_system_results?.()).toEqual(
+            initializer_system_results,
+        );
+    });
+});
+
+describe("isVibleTest Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                overrideSel: {
+                    hwclOpahwc: "Trough detect configuration with unity gain feedback",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for isVisible", () => {
+        expect(derivedFunctions.isVisible?.("ptresOpacon4")).toEqual(true);
+    });
+});
+
+describe("API Tests", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        state: {
+            ...mockModule.state,
+            main: {
+                hardware: {
+                    customConfig: "Non-Inverting Programmable Gain Amplifier",
+                },
+                channelSel: {
+                    nchOpacon2: "GSEL",
+                },
+                overrideSel: {
+                    hwchOpahwc: "Peak detect configuration with user defined feedback",
+                    hwclOpahwc: "Trough detect configuration with unity gain feedback",
+                },
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for moduleName", () => {
+        expect(derivedFunctions.moduleName?.()).toEqual("OPA2");
+    });
+
+    const pin_args = { queryAdapterMap: { allpins: "^OPA[0-9]$" } };
+
+    it("Test for pin_standard_args", () => {
+        expect(derivedFunctions.pin_standard_args?.()).toEqual(pin_args);
+    });
+
+    it("Test for doNotShow", () => {
+        expect(derivedFunctions.doNotShow?.()).toEqual(false);
+    });
+
+    it("Test for isEnabled", () => {
+        expect(derivedFunctions.isEnabled?.("nssOpacon1")).toEqual(true);
+    });
+
+    it("Test for isVisible", () => {
+        expect(derivedFunctions.isVisible?.("ptresOpacon4")).toEqual(true);
+    });
+});
+
+describe("API Test with Undefined Values", () => {
+    let mockModule = mockAssignedModule(mockState());
+    mockModule = {
+        ...mockModule,
+        imports: {
+            ...mockModule.imports,
+            scf_pic8_opamp_v2: {
+                interfaceId: {
+                    name: "scf-pic8-opamp-v2",
+                    version: "1.0.0",
+                },
+                handle: undefined,
+                payload: undefined,
+            },
+        },
+    };
+
+    const model = getModel(mockModule, getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    it("Test for undefined Hardware", () => {
+        expect(derivedFunctions.moduleName?.()).toEqual("OPA");
+        expect(derivedFunctions.alerts?.()).toBeDefined();
+        expect(
+            derivedFunctions?.["opa-output-parameters_payload"]?.()?.moduleName,
+        ).toEqual("OPA");
+    });
+});