@mchp-mcc/scf-pic8-pwm-v2 4.2.4 → 4.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mchp-mcc/scf-pic8-pwm-v2",
-    "version": "4.2.4",
+    "version": "4.2.5",
     "scf": {
         "reducer": "auto",
         "creator": "output/creator.js",
@@ -106,7 +106,7 @@
         "build-run-dir-future": "node config/extract-run-directory-future.js",
         "release": "yarn build && yarn test && node -e 'require(\"./config/scf-project-scripts\").releaseProject()'",
         "test:itf:all": "node ./node_modules/@mchp-mcc/ccl-itf/lib/index.js --sp=./tests/itf --rd=./run",
-        "test:itf:dev": "node ./node_modules/@mchp-mcc/ccl-itf/lib/index.js --sp=./tests/itf --rd=./run --sf=pwmV2.major.test.ts --df=\"PIC16F18875|PIC16F18854|PIC16LF18856\"",
+        "test:itf:dev": "node ./node_modules/@mchp-mcc/ccl-itf/lib/index.js --sp=./tests/itf --rd=./run --sf=pwmV2.major.test.ts --df=\"PIC16F18076\"",
         "postprocess": "node config/appendPrototype.js"
     },
     "husky": {
@@ -136,7 +136,15 @@
             "<rootDir>/run"
         ],
         "preset": "ts-jest",
-        "collectCoverage": true
+        "collectCoverage": true,
+        "coverageThreshold": {
+            "./src": {
+                "branches": 80,
+                "functions": 80,
+                "lines": 80,
+                "statements": 80
+            }
+        }
     },
     "dependencies": {
         "@microchip/api-prefix-registration": "^0.1.0",
@@ -162,8 +170,8 @@
         "@babel/preset-react": "^7.9.4",
         "@babel/preset-typescript": "^7.9.0",
         "@mchp-mcc/ccl-itf": "^0.2.16",
-        "@mchp-mcc/pic-8bit": "^5.4.5",
-        "@mchp-mcc/pic-8bit-types": "^5.4.1",
+        "@mchp-mcc/pic-8bit": "^5.9.0-dev.5",
+        "@mchp-mcc/pic-8bit-types": "^5.9.0-dev.5",
         "@microchip/initializer-system": "^0.5.3",
         "@microchip/melody-automodule-interface": "^1.5.1",
         "@microchip/pic-8bit-types": "^5.0.1",

package/src/DerivedData.test.ts

@@ -0,0 +1,616 @@
+import { DerivedData } from "../generated_module/src/types/AutoModuleTypes";
+import * as MyDerivedData from "./DerivedData";
+import { AppModel, MyState } 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";
+
+export const getMockState = (
+    pwmenPwmcon: boolean | undefined,
+    timerSelection: string | undefined,
+    tmr2Dependency: string | undefined,
+): MyState => {
+    return {
+        main: {
+            software: {
+                componentName: "PWM4",
+                tmr2Dependency: tmr2Dependency,
+            },
+            hardware: {
+                timerSelection: timerSelection,
+                dutyCycle: 50,
+                pwmdcValue: 511,
+                pwmPeriod: 0.001024,
+                pwmFrequency: 976.56,
+                pwmResolution: 10,
+                pwmpolPwmcon: "active_hi",
+                pwmenPwmcon: pwmenPwmcon,
+            },
+        },
+    };
+};
+
+describe("Empty Derived Data Test ", () => {
+    const derivedData = getDerivedData((undefined as unknown) as AppModel);
+
+    it("Get My Functions Test ", () => {
+        expect(derivedData.getMyFunctions()).toStrictEqual({});
+    });
+    it("Get Model Test ", () => {
+        expect(derivedData.getModel()).toStrictEqual(undefined);
+    });
+});
+
+describe("Import Interface test Cases ", () => {
+    const mockMod = mockAssignedModule(mockState());
+    const model = getModel(mockMod, MyDerivedData.getDerivedData);
+    const derivedData = model?.getDerivedData() as DerivedData;
+    const derivedFunctions = derivedData?.getMyFunctions();
+
+    const sysInitImport = {
+        initializer: {
+            name: "PWM_Initialize",
+            header: { name: "pwm.h", path: "pwm/" },
+        },
+    };
+    it("Test for initializer import interface name and version defined", () => {
+        expect(model?.getImports()?.initializer_system?.interfaceId.name).toEqual(
+            "initializer-system",
+        );
+        expect(
+            model?.getImports()?.initializer_system?.interfaceId.version,
+        ).toBeDefined();
+    });
+    it("Test for initializer values", () => {
+        expect(derivedFunctions?.initializer_system_results()?.initializer?.name).toEqual(
+            sysInitImport?.initializer?.name,
+        );
+    });
+    it("Test for pin import interface name and version defined", () => {
+        expect(model?.getImports()?.pin_standard?.interfaceId.name).toEqual(
+            "pin-standard",
+        );
+        expect(model?.getImports()?.pin_standard?.interfaceId.version).toBeDefined();
+    });
+    it("Test for device_meta import interface name and version defined", () => {
+        expect(model?.getImports()?.device_meta?.interfaceId.name).toEqual("device-meta");
+        expect(model?.getImports()?.device_meta?.interfaceId.version).toBeDefined();
+    });
+    it("Test for pwm hw import interface name and version defined", () => {
+        expect(model?.getImports()?.scf_pic8_pwm_v2?.interfaceId.name).toEqual(
+            "scf-pic8-pwm-v2",
+        );
+        expect(model?.getImports()?.scf_pic8_pwm_v2?.interfaceId.version).toBeDefined();
+    });
+
+    it("Test for clock import interface name and version defined", () => {
+        expect(model?.getImports()?.osc_clocks?.interfaceId.name).toEqual("osc-clocks");
+        expect(model?.getImports()?.osc_clocks?.interfaceId.version).toBeDefined();
+    });
+
+    // it("Import osc_clocks is undefined", () => {
+    //     if (model) {
+    //         model.getImportValue = (int_name: string): any => {
+    //             return undefined;
+    //         };
+    //     }
+    //     const systemClock = derivedFunctions?.systemClock?.();
+    //     expect(systemClock).toBe("0.000 Hz");
+    // });
+});
+
+describe("Alert test Cases ", () => {
+    describe("Default: Timer 2 Dependency Selector ", () => {
+        const model = getModel(
+            mockAssignedModule(getMockState(true, "TMR2", "None")),
+            MyDerivedData.getDerivedData,
+        );
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        const alert1 = {
+            type: "warning",
+            text: "Please select TMR2 as the Timer Dependency.",
+        };
+        it("Test for Alerts value", () => {
+            expect(derivedFunctions.alerts?.()).toEqual([alert1]);
+        });
+    });
+    describe("Default:  Timer 4 Dependency Selector", () => {
+        const model = getModel(
+            mockAssignedModule(getMockState(true, "TMR4", "None")),
+            MyDerivedData.getDerivedData,
+        );
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        const alert1 = {
+            type: "warning",
+            text: "Please select TMR4 as the Timer Dependency.",
+        };
+        it("Test for Alerts value", () => {
+            expect(derivedFunctions.alerts?.()).toEqual([alert1]);
+        });
+    });
+    describe("Default:  Timer 6 Dependency Selector", () => {
+        const model = getModel(
+            mockAssignedModule(getMockState(true, "TMR6", "None")),
+            MyDerivedData.getDerivedData,
+        );
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        const alert1 = {
+            type: "warning",
+            text: "Please select TMR6 as the Timer Dependency.",
+        };
+        it("Test for Alerts value", () => {
+            expect(derivedFunctions.alerts?.()).toEqual([alert1]);
+        });
+    });
+
+    describe("PWM Alerts: TMR dependency selector configured correctly", () => {
+        let mockModule = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+        mockModule = {
+            ...(mockModule ?? {}),
+            imports: {
+                ...(mockModule?.imports ?? {}),
+                Timer: {
+                    ...(mockModule?.imports?.Timer ?? {}),
+                    handle: {
+                        ...(mockModule?.imports?.Timer?.handle ?? {}),
+                        providerId: "module15",
+                        exportId: "timer_2_4_6_general_params",
+                        label: "TMR2",
+                    },
+                    payload: {
+                        ...(mockModule?.imports?.Timer?.payload ?? {}),
+                        moduleName: "TMR2",
+                    },
+                },
+            },
+        };
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        const alert1 = {
+            type: "hint",
+            text: "PWM4 uses TMR2.",
+        };
+        const alert2 = {
+            type: "hint",
+            text:
+                "Postscaler setting in TMR2 does not affect the calculated parameters in PWM module.",
+        };
+        it("Test for Alerts value", () => {
+            expect(derivedFunctions.alerts?.()).toEqual([alert1, alert2]);
+        });
+    });
+});
+
+describe("DerivedData for APIs: FilterImports -- >", () => {
+    test("Filter imports", () => {
+        type importData = {
+            importKey: string;
+            importValue: string;
+        };
+        const data: importData[] = [
+            { importKey: "Timer", importValue: "TMR2" },
+            { importKey: "Timer", importValue: "DUMMY" },
+        ];
+        for (let i = 0; i < data.length; i++) {
+            let mockState: MyState = {};
+            mockState = getMockState(true, "TMR2", data[i].importValue);
+            mockState = {
+                ...mockState,
+                imports: {
+                    ...mockState.imports,
+                    Timer: {
+                        options: [
+                            {
+                                payload: {
+                                    moduleName: "Timer",
+                                },
+                            },
+                        ],
+                    },
+                },
+            };
+            const model = getModel(
+                mockAssignedModule(mockState),
+                getDerivedData,
+            ) as AppModel;
+
+            const derivedData = model?.getDerivedData() as DerivedData;
+            const derivedFunctions = derivedData?.getMyFunctions();
+            if (data[i].importValue !== "DUMMY") {
+                expect(
+                    derivedFunctions?.filterImports?.(mockState?.imports)[
+                        data[i].importKey
+                    ],
+                ).toBeDefined();
+            } else {
+                expect(
+                    derivedFunctions?.filterImports?.(mockState?.imports)[
+                        data[i].importKey
+                    ],
+                ).toEqual({
+                    options: [],
+                });
+            }
+        }
+    });
+});
+
+describe("DerivedData for APIs: Processed payload -- >", () => {
+    describe("Timer 2 -->", () => {
+        const mockModule = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        it("Test for Selected Tmr", () => {
+            expect(derivedFunctions?.pwm_general_parameters_payload?.()).toBeDefined();
+        });
+    });
+});
+
+describe("DerivedData for APIs: Timer selection -- >", () => {
+    describe("Timer 2 -->", () => {
+        const mockModule = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        it("Test for Selected Tmr", () => {
+            expect(derivedFunctions?.ctselPwmtmrs?.()).toEqual("PWM4timer2");
+        });
+    });
+    describe("Timer 4 -->", () => {
+        const mockModule = mockAssignedModule(getMockState(true, "TMR4", "TMR4"));
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        it("Test for Selected Tmr", () => {
+            expect(derivedFunctions?.ctselPwmtmrs?.()).toEqual("PWM4timer4");
+        });
+    });
+    describe("No-->", () => {
+        const mockModule = mockAssignedModule(getMockState(true, "TMR6", "TMR6"));
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        it("Test for Selected Tmr", () => {
+            expect(derivedFunctions?.ctselPwmtmrs?.()).toEqual("PWM4timer6");
+        });
+    });
+    describe("No PWM Timer -->", () => {
+        const mockModule = mockAssignedModule(getMockState(true, undefined, "None"));
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        it("Test for Selected Tmr", () => {
+            expect(derivedFunctions?.ctselPwmtmrs?.()).toEqual("PWM4timer2");
+        });
+    });
+    describe("Invalid Timer 7 -->", () => {
+        const mockModule = mockAssignedModule(getMockState(true, "TMR7", "TMR7"));
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        it("Test for Selected Tmr", () => {
+            expect(derivedFunctions?.ctselPwmtmrs?.()).toBeUndefined();
+        });
+    });
+});
+
+describe("DerivedData for APIs: sdl help override -- >", () => {
+    describe("DerivedData for APIs -- >", () => {
+        const mockModule = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+        const model = getModel(mockModule, MyDerivedData.getDerivedData);
+        const derivedData = model?.getDerivedData() as DerivedData;
+        const derivedFunctions = derivedData?.getMyFunctions();
+        it("Test for Pin Data value", () => {
+            expect(derivedFunctions?.pinData()).toEqual({});
+        });
+        it("Test for Module Name value", () => {
+            expect(derivedFunctions?.moduleName?.()).toEqual("PWM4");
+        });
+        // it("Test for Custom Name value", () => {
+        //     expect(derivedFunctions?.componentName?.()).toEqual(undefined);
+        // });
+        it("Test for overrideDefaultValues", () => {
+            expect(derivedFunctions?.overrideOptions?.("componentName")).toEqual([]);
+        });
+        // it("Test for overrideOptions", () => {
+        //     //expect(derivedFunctions?.overrideOptions?.("ccpTimer")).toEqual([]);
+        //     expect(derivedFunctions?.overrideOptions?.("timerSelection")).toEqual([
+        //         "TMR2",
+        //         "TMR4",
+        //         "TMR6"
+        //     ]);
+        // });
+        it("Test for overrideOptions CCPTMRS1", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                CCPTMRS1: {
+                                    ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                        ?.registers?.CCPTMRS1 ?? {}),
+                                    settings: undefined,
+                                },
+                                CCPTMRS: undefined,
+                                PWMTMRS: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            // expect(mockDerivedFunctions?.overrideOptions?.("ccpTimer")).toEqual([]);
+            expect(mockDerivedFunctions?.overrideOptions?.("timerSelection")).toEqual([]);
+        });
+
+        it("Test for overrideOptions PWMTMRS", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                PWMTMRS: {
+                                    ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                        ?.registers?.PWMTMRS ?? {}),
+                                    settings: undefined,
+                                },
+                                CCPTMRS: undefined,
+                                CCPTMRS1: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            // expect(mockDerivedFunctions?.overrideOptions?.("ccpTimer")).toEqual([]);
+            expect(mockDerivedFunctions?.overrideOptions?.("timerSelection")).toEqual([]);
+        });
+
+        it("Test for no overrideOptions", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                PWMTMRS: undefined,
+                                CCPTMRS: undefined,
+                                CCPTMRS1: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            // expect(mockDerivedFunctions?.overrideOptions?.("ccpTimer")).toEqual([]);
+            expect(mockDerivedFunctions?.overrideOptions?.("timerSelection")).toEqual([
+                "TMR2",
+            ]);
+        });
+
+        it("Test for sdl help override dutyclyce and pwmdcValue", () => {
+            //expect(derivedFunctions?.overrideOptions?.("ccpTimer")).toEqual([]);
+            expect(derivedFunctions?.getHelpUrl?.("dutyCycle", "help")).toEqual("help");
+            expect(derivedFunctions?.getHelpUrl?.("pwmdcValue", "help")).toEqual("help");
+        });
+        it("Test for sdl help override ccp timer 1", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                CCPTMRS1: {
+                                    ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                        ?.registers?.CCPTMRS1 ?? {}),
+                                    settings: undefined,
+                                },
+                                CCPTMRS: undefined,
+                                PWMTMRS: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            expect(
+                mockDerivedFunctions?.getHelpUrl?.("timerSelection", "ctselCcptmrs1"),
+            ).toEqual("ctselCcptmrs1");
+        });
+        it("Test for sdl help override ccp timer", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                CCPTMRS: {
+                                    ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                        ?.registers?.CCPTMRS ?? {}),
+                                    settings: undefined,
+                                },
+                                CCPTMRS1: undefined,
+                                PWMTMRS: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            expect(
+                mockDerivedFunctions?.getHelpUrl?.("timerSelection", "ctselCcptmrs"),
+            ).toEqual("ctselCcptmrs");
+        });
+        it("Test for sdl help override pwm timer", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                PWMTMRS: {
+                                    ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                        ?.registers?.PWMTMRS ?? {}),
+                                    settings: undefined,
+                                },
+                                CCPTMRS: undefined,
+                                CCPTMRS1: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            expect(
+                mockDerivedFunctions?.getHelpUrl?.("timerSelection", "ctselPwmtmrs"),
+            ).toEqual("ctselPwmtmrs");
+        });
+
+        it("Test for sdl help override pwm timer", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                PWMTMRS: {
+                                    ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                        ?.registers?.PWMTMRS ?? {}),
+                                    CTSEL: "PWM4timer2",
+                                },
+                                CCPTMRS: undefined,
+                                CCPTMRS1: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            expect(
+                mockDerivedFunctions?.getHelpUrl?.("timerSelection", "ctselPwmtmrs"),
+            ).toEqual("ctselPwmtmrs");
+        });
+
+        it("Test for sdl help override register undefined", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: {
+                            ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload ?? {}),
+                            registers: {
+                                ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2?.payload
+                                    ?.registers ?? {}),
+                                PWMTMRS: undefined,
+                                CCPTMRS: undefined,
+                                CCPTMRS1: undefined,
+                            },
+                        },
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            expect(
+                mockDerivedFunctions?.getHelpUrl?.("timerSelection", "ctselPwmtmrs"),
+            ).toEqual("ctselPwmtmrs");
+        });
+        it("Test for sdl help override register undefined", () => {
+            let mockAssignedMod = mockAssignedModule(getMockState(true, "TMR2", "TMR2"));
+            mockAssignedMod = {
+                ...(mockAssignedMod ?? {}),
+                imports: {
+                    ...(mockAssignedMod?.imports ?? {}),
+                    scf_pic8_pwm_v2: {
+                        ...(mockAssignedMod?.imports?.scf_pic8_pwm_v2 ?? {}),
+                        payload: undefined,
+                    },
+                },
+            };
+            const mockModel = getModel(mockAssignedMod, MyDerivedData.getDerivedData);
+            const mockDerivedData = mockModel?.getDerivedData() as DerivedData;
+            const mockDerivedFunctions = mockDerivedData?.getMyFunctions();
+            expect(
+                mockDerivedFunctions?.getHelpUrl?.("timerSelection", "ctselPwmtmrs"),
+            ).toEqual("ctselPwmtmrs");
+        });
+        describe("Empty DerivedData -- >", () => {
+            let emptyModel: AppModel;
+            it("Test for EmptyDerivedData", () => {
+                expect(
+                    MyDerivedData?.getDerivedData(emptyModel)?.getMyFunctions(),
+                ).toEqual({});
+                expect(
+                    MyDerivedData?.getDerivedData(emptyModel)?.getModel(),
+                ).toBeUndefined();
+            });
+        });
+    });
+});