@mchp-mcc/clock-16bit-driver 1.1.0 → 1.2.0

package/tests/itf/clock.test.ts

@@ -0,0 +1,1165 @@
+import { TestCaseAPIs } from "@microchip/ccl-itf/lib/apis/TestCaseAPIs";
+import { ReportAPIs } from "@microchip/ccl-itf/lib/apis/ReportAPIs";
+import  * as  utils from "./Utils";
+
+const addMsg = require("@microchip/melody-itf-reporters/lib/helper").addMsg;
+const itfConfig = require("../../reports/itf.config.json"); // This file is automatically generated by CCL-ITF.
+ 
+let testAPI: TestCaseAPIs;
+let reportAPI: ReportAPIs;
+
+const devices: string[] = itfConfig.devices;
+const runDir: string = itfConfig.runDir;
+const MAX_LAUNCH_TIMEOUT = 1000000; // in ms
+const MAX_TESTCASE_TIMEOUT = 700000; // in ms
+const MAX_CMD_TIMEOUT = 90000; // in ms (this is optional, default is 60000ms)
+let PLIBModuleId:any = "";
+let driverModuleId:any = "";
+let pinModuleId:any = "";
+let configBitsModuleId="";
+
+const PLIBmoduleInfo = {
+    name: '@mchp-mcc/pic24-dspic33-clock-sib',
+    version: '>=1.0.0'
+}
+const driverModuleInfo = {
+    name: '@mchp-mcc/clock-16bit-driver',
+    version: '>=1.0.0'
+}
+const PCPModuleInfo = {
+    name: '@mchp-mcc/pin-content-processor',
+    version: '>=1.0.0'
+}
+const configBitsModuleInfo = {
+    name: '@mchp-mcc/dspic33-configuration-bits',
+    version: '>=1.0.0'
+}
+const setup = async () => {
+    try {
+        testAPI = new TestCaseAPIs();
+        reportAPI = new ReportAPIs();
+        await testAPI.setup(runDir);
+        await reportAPI.setup(runDir);
+    } catch (e) {
+        throw e;
+    }
+}
+
+/*
+* Test cases
+*/
+describe("Clock Driver", () => {
+    beforeAll(async () => {
+        await setup();
+        await testAPI.start();
+    }, MAX_LAUNCH_TIMEOUT);
+ 
+    afterAll(async () => {
+        await testAPI.close();
+    });
+ 
+    beforeEach(async () => {
+        await reportAPI.cleanupLog();
+    });
+ 
+    afterEach(async () => {     
+        const log: string = await reportAPI.getLogData();
+        await addMsg(log);
+    });
+    const loadModulebyId = async () => {
+        const deriverModule = await testAPI.getModuleIdsforInterface(driverModuleInfo);
+        expect(deriverModule.length).toBeGreaterThan(0);
+        driverModuleId = deriverModule[0];
+        const PLIBModule = await testAPI.getModuleIdsforInterface(PLIBmoduleInfo);
+        expect(PLIBModule.length).toBeGreaterThan(0);
+        PLIBModuleId = PLIBModule[0];
+        const pinModule= await testAPI.getModuleIdsforInterface(PCPModuleInfo);
+        expect(pinModule.length).toBeGreaterThan(0);
+        pinModuleId = pinModule[0];
+        const configBitsModule= await testAPI.getModuleIdsforInterface(configBitsModuleInfo);
+        configBitsModuleId = configBitsModule[0];
+    };
+ 
+//Module testcases
+describe.each(devices)("%s", (device) => {
+    describe("TID_1 Basic Setting", () => {
+        test("TID_1-1 Load Module and generate code with default setting", async () => {
+            expect(await testAPI.loadDevice(device)).toBe(true);
+            await loadModulebyId();
+            expect(await testAPI.generateCode()).toBeTruthy();
+            const projectName = `${device}.default.clock.X`;
+            expect(await testAPI.saveProjectAs(projectName, true)).toBeTruthy();
+            },MAX_TESTCASE_TIMEOUT);
+        });
+    //     // 
+    describe("TID_2 System Clock for different clock input sources", () => {
+       test("TID_2-1 For the input clock source Primary Oscillator with PLL, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','Primary Oscillator with PLL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','Primary Oscillator with PLL')).toBeTruthy();
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy();
+        
+           await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2');
+           expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2')).toBeTruthy();
+        
+           const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+        
+           expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.oscOutputPinConfig',"OSC2 is clock output")).toBeTruthy();
+           expect(utils.getHiddenProperty(PLIBData,"software","clockOutputPinConfig")).toBe("hidden");
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',18000000);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',18000000)).toBeTruthy();
+           const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("Primary Oscillator with PLL");
+        
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(2);
+        
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+        
+            expect(utils.getHiddenProperty(DriverData,"systemClock","requestedSystemFrequency_Hz")).toBe("hidden");
+            
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCO$output'])?.name == "OSCO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCI$input'])?.name == "OSCI").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCO$output'])?.pins?.['RB1']?.state).toBe('L');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCI$input'])?.pins?.['RB0']?.state).toBe('L');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+        
+            if(device.match("dsPIC33CH[0-9]+MP5[0-9]+$")){
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"180.00 MHz")).toBe(true);  
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"90.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"360.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"720.00 MHz")).toBe(true);
+        
+                expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("PRIPLL");
+                expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("90");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:2");
+        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("XT");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("OFF");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","pllkenFosc")).toBe("PLLKEN_ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSECMD");
+        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("FRC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+        
+                expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x300");
+                expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x5a");
+                expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x221");
+            }
+            
+            if(device.match("dsPIC33C[^H]+[0-9]+M[A-Z][0-9]+$")){
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"199.13 MHz")).toBe(true); 
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"99.56 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"398.25 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1593.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"796.50 MHz")).toBe(true);
+        
+                expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("PRIPLL");
+                expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("50");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:1");
+        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("XT");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("OFF");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","pllkenFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSECMD");
+        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("FRC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+        
+                expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x300");
+                expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x32");
+                expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x211");
+            }
+            if(device.match("dsPIC33CH[0-9]+MP5[0-9]+S1$")){
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"199.13 MHz")).toBe(true); 
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"99.56 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"398.25 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1593.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"796.50 MHz")).toBe(true);
+            }
+           },MAX_TESTCASE_TIMEOUT);
+        
+        test("TID_2-2 For the input clock source FRC Oscillator with Postscaler, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','FRC Oscillator with Postscaler');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','FRC Oscillator with Postscaler')).toBeTruthy();
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy();
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','4');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','4')).toBeTruthy();
+        
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("FRC Oscillator with Postscaler");
+        
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(4);
+        
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+        
+            expect(utils.getHiddenProperty(DriverData,"systemClock","requestedSystemFrequency_Hz")).toBe("hidden");
+            expect(utils.getHiddenProperty(DriverData,"systemClock","mainClockInputFrequency_Hz")).toBe("hidden");
+        
+              
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+            expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.clockOutputPinConfig',"OSC2 is general purpose digital i/o pin")).toBeTruthy();
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+            expect(utils.getHiddenProperty(PLIBData,"software","oscOutputPinConfig")).toBe("hidden");
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.name == "CLKO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.pins?.['RB1']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"8.00 MHz")).toBe(true);  
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"4.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"300.00 MHz")).toBe(true);
+    
+            expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("FRCDIV");
+            expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("150");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/4");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:4");
+            expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x700");
+            expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x96");
+            expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x41");
+            if(device.match("dsPIC33C[A-Z]+[0-9]+M[A-Z][0-9]+$")){        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("NONE");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSDCMD");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("FRCDIV");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+            }
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_2-3 For the input clock source FRC Oscillator, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','FRC Oscillator');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','FRC Oscillator')).toBeTruthy();
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy();
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','4');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','4')).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("FRC Oscillator");
+        
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(4);
+        
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+        
+            expect(utils.getHiddenProperty(DriverData,"systemClock","requestedSystemFrequency_Hz")).toBe("hidden");
+            expect(utils.getHiddenProperty(DriverData,"systemClock","mainClockInputFrequency_Hz")).toBe("hidden");
+        
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.clockOutputPinConfig',"OSC2 is general purpose digital i/o pin")).toBeTruthy();
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+            expect(utils.getHiddenProperty(PLIBData,"software","oscOutputPinConfig")).toBe("hidden");
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.name == "CLKO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.pins?.['RB1']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"8.00 MHz")).toBe(true);  
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"4.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"300.00 MHz")).toBe(true);
+            expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("FRC");
+            expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("150");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/4");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:4");
+            if(device.match("dsPIC33C[A-Z]+[0-9]+M[A-Z][0-9]+$")){        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("NONE");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSDCMD");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("FRC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+            }
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_2-4 For the input clock source FRC Oscillator with PLL, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','FRC Oscillator with PLL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','FRC Oscillator with PLL')).toBeTruthy();
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',false);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',false)).toBeTruthy();
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.requestedSystemFrequency_Hz',"18000000");
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.requestedSystemFrequency_Hz',"18000000")).toBeTruthy();
+            
+        
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2')).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("FRC Oscillator with PLL");
+        
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(false);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(2);
+        
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+        
+            expect(utils.getHiddenProperty(DriverData,"systemClock","mainClockInputFrequency_Hz")).toBe("hidden");
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+            expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.clockOutputPinConfig',"OSC2 is general purpose digital i/o pin")).toBeTruthy();
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+            expect(utils.getHiddenProperty(PLIBData,"software","oscOutputPinConfig")).toBe("hidden");
+        
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.name == "CLKO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.pins?.['RB1']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"18.00 MHz")).toBe(true);  
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"9.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"36.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"432.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"216.00 MHz")).toBe(true);
+            
+            expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("FRCPLL");
+            expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("54");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:6");
+            expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x100");
+            expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x36");
+            expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x262");
+            if(device.match("dsPIC33C[A-Z]+[0-9]+M[A-Z][0-9]+$")){
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("NONE");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSECMD");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("FRC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+            }
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_2-5 For the input clock source Primary Oscillator, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','Primary Oscillator');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','Primary Oscillator')).toBeTruthy();
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy();
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',"15000000");
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',"15000000")).toBeTruthy();
+            
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2')).toBeTruthy();
+        
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("Primary Oscillator");
+            
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(2);
+            
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+            
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+            expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.oscOutputPinConfig',"OSC2 is clock output")).toBeTruthy();
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+            expect(utils.getHiddenProperty(PLIBData,"software","clockOutputPinConfig")).toBe("hidden");
+        
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCO$output'])?.name == "OSCO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCI$input'])?.name == "OSCI").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCO$output'])?.pins?.['RB1']?.state).toBe('L');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$OSCI$input'])?.pins?.['RB0']?.state).toBe('L');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"15.00 MHz")).toBe(true);  
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"7.50 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"600.00 MHz")).toBe(true);
+            expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("PRI");
+            expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("150");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:4");
+            expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x200");
+            expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x96");
+            expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x241");
+            if(device.match("dsPIC33C[A-Z]+[0-9]+M[A-Z][0-9]+$")){
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("HS");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("OFF");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSDCMD");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("PRI");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+            }
+            },MAX_TESTCASE_TIMEOUT);
+            if(device.match("dsPIC33C[A-Z]+[0-9]+MP[0-9]+$")){
+                test("TID_2-6 For the input clock source LPRC Oscillator, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','LPRC Oscillator');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','LPRC Oscillator')).toBeTruthy();
+                    
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy();            
+                    
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2')).toBeTruthy();
+                
+                    const DriverData = await testAPI.getModuleData(driverModuleId);
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("LPRC Oscillator");
+                    
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(2);
+                    
+                    expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+                    expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+                    
+                    expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+                    expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+                    
+                    expect(utils.getHiddenProperty(DriverData,"systemClock","mainClockInputFrequency_Hz")).toBe("hidden");
+                    const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                    expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.clockOutputPinConfig',"OSC2 is general purpose digital i/o pin")).toBeTruthy();
+                    expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+                    expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+                    expect(utils.getHiddenProperty(PLIBData,"software","oscOutputPinConfig")).toBe("hidden");
+                
+                    const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+                    const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+                    expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.name == "CLKO").toBe(true);
+                    expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.pins?.['RB1']?.state).toBe('UL');
+                    expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+                    expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"32.00 kHz")).toBe(true);  
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"16.00 kHz")).toBe(true);
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"1200.00 MHz")).toBe(true);
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1200.00 MHz")).toBe(true);
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"600.00 MHz")).toBe(true);
+            
+                    expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("LPRC");
+                    expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("150");
+                    expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+                    expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:4");
+                    expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x500");
+                    expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x96");
+                    expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x241");
+                    if(device.match("dsPIC33C[A-Z]+[0-9]+M[A-Z][0-9]+$")){                
+                        expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("NONE");
+                        expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                        expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSDCMD");
+                        expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("LPRC");
+                        expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+                    }
+                    },MAX_TESTCASE_TIMEOUT);
+            }
+        test("TID_2-7 For the input clock source External Oscillator with PLL, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','External Oscillator with PLL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','External Oscillator with PLL')).toBeTruthy();
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy();
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',8000000);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',8000000)).toBeTruthy();
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2')).toBeTruthy();
+        
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("External Oscillator with PLL");
+            
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(2);
+            
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+            expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.clockOutputPinConfig',"OSC2 is general purpose digital i/o pin")).toBeTruthy();
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+            expect(utils.getHiddenProperty(PLIBData,"software","oscOutputPinConfig")).toBe("hidden");
+        
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.name == "CLKO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.pins?.['RB1']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+            
+            if(device.match("dsPIC33CH[0-9]+MP5[0-9]+$")){
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"180.00 MHz")).toBe(true);  
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"90.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"360.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"720.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"360.00 MHz")).toBe(true);
+        
+                expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("PRIPLL");
+                expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("90");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:2");
+        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("EC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","pllkenFosc")).toBe("PLLKEN_ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSECMD");
+        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("FRC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+            
+                expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x300");
+                expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x5a");
+                expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x221");
+            }
+            if(device.match("dsPIC33C[^H]+[0-9]+M[A-Z][0-9]+$")){
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"200.00 MHz")).toBe(true);  
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"100.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"400.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"400.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"200.00 MHz")).toBe(true);
+                expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("PRIPLL");
+                expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("50");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+                expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:1");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("EC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSECMD");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("FRC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+                expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x300");
+                expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x32");
+                expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x211");
+            }
+            if(device.match("dsPIC33CH[0-9]+MP5[0-9]+S1$")){
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"200.00 MHz")).toBe(true); 
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"100.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"400.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"400.00 MHz")).toBe(true);
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"200.00 MHz")).toBe(true); 
+            }
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_2-8 For the input clock source External Oscillator, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','External Oscillator');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','External Oscillator')).toBeTruthy();
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy(); 
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',9000000);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockInputFrequency_Hz',9000000)).toBeTruthy();
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2')).toBeTruthy();
+        
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("External Oscillator");
+            
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(2);
+            
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+            
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+            expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.clockOutputPinConfig',"OSC2 is general purpose digital i/o pin")).toBeTruthy();
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+            expect(utils.getHiddenProperty(PLIBData,"software","oscOutputPinConfig")).toBe("hidden");
+        
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.name == "CLKO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"9.00 MHz")).toBe(true);  
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"4.50 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"600.00 MHz")).toBe(true);
+    
+            expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("PRI");
+            expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("150");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:4");
+
+            expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x200");
+            expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x96");
+            expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x241");
+            if(device.match("dsPIC33C[A-Z]+[0-9]+M[A-Z][0-9]+$")){        
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("EC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSDCMD");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("PRI");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+            }
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_2-9 For the input clock source BFRC Oscillator, Verify the Calculated FOSC/2, FPLLO, FVCO, FVCODIV, Pin configuration and derived configBit Registers settings", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','BFRC Oscillator');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.mainClockSource','BFRC Oscillator')).toBeTruthy();
+                
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.setMaximumSystemFrequency',true)).toBeTruthy(); 
+                            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDivider','2')).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.mainClockSource).toBe("BFRC Oscillator");
+                
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.setMaximumSystemFrequency).toBe(true);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","mainClockArg")?.fvcoDivider).toBe(2);
+                
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","calculatedSystemFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","instructionClockFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fpllo")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"systemClock","fvco")).toBe(true);
+                
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            const configBitsData = await testAPI.getModuleData(configBitsModuleId);
+            expect(await testAPI.assertAutoModuleProperty(PLIBModuleId, 'main','software.clockOutputPinConfig',"OSC2 is general purpose digital i/o pin")).toBeTruthy();
+            expect(utils.getReadOnlyValue(PLIBData,"software","clockOutputPinConfig")).toBe(true);
+            expect(utils.getReadOnlyValue(PLIBData,"software","oscOutputPinConfig")).toBe(true);
+            expect(utils.getHiddenProperty(PLIBData,"software","oscOutputPinConfig")).toBe("hidden");
+            
+            const pinModuleData:any = await testAPI.getModuleData(pinModuleId);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.name == "CLKO").toBe(true);
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$CLKO$output'])?.pins?.['RB1']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFO$output'])?.pins?.['RB0']?.state).toBe('UL');
+            expect(utils.getModulepins(pinModuleData,PLIBModuleId,['INTERNAL OSCILLATOR$REFI$input'])?.pins?.['RB0']?.state).toBe('MUL');
+    
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.calculatedSystemFrequency_Hz',"8.00 MHz")).toBe(true);  
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.instructionClockFrequency_Hz',"4.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fpllo',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvco',"1200.00 MHz")).toBe(true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','systemClock.fvcoDiv',"600.00 MHz")).toBe(true);
+            expect(utils.getSettingBit(PLIBData,"OSCCON","NOSC")).toBe("BFRC");
+            expect(utils.getSettingBit(PLIBData,"PLLFBD","PLLFBDIV")).toBe("150");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","VCODIV")).toBe("FVCO/2");
+            expect(utils.getSettingBit(PLIBData,"PLLDIV","POST1DIV")).toBe("1:4");
+            expect(utils.getRegisterValue(PLIBData,"OSCCON")).toBe("OSCCON : 0x600");
+            expect(utils.getRegisterValue(PLIBData,"PLLFBD")).toBe("PLLFBD : 0x96");
+            expect(utils.getRegisterValue(PLIBData,"PLLDIV")).toBe("PLLDIV : 0x241");
+            if(device.match("dsPIC33C[A-Z]+[0-9]+M[A-Z][0-9]+$")){
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","poscmodFosc")).toBe("NONE");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","osciofcnFosc")).toBe("ON");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSC","fcksmFosc")).toBe("CSDCMD");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","fnoscFoscsel")).toBe("BFRC");
+                expect(utils.getConfigBitsSettingBit(configBitsData,"FOSCSEL","iesoFoscsel")).toBe("OFF");
+                }
+            },MAX_TESTCASE_TIMEOUT);
+
+        });
+    if(device.match("dsPIC33C[A-Z]+[0-9]+M[^C]+[0-9]+")){
+        describe("TID_3 Auxiliary Clock", () => {
+            test("TID_3-1 For the Auxiliary clock source Primary Oscillator with PLL , Verify the Calculated AFPLLO, AFVCO, AFVCODIV and derived Registers settings", async () => {
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','Primary Oscillator with PLL');
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','Primary Oscillator with PLL')).toBeTruthy();
+                
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','auxClock.afvcoDivider','2');
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','auxClock.afvcoDivider','2')).toBeTruthy();
+                
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","auxClockArg")?.auxClockSource).toBe("Primary Oscillator with PLL");
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","auxClockArg")?.afvcoDivider).toBe(2);
+                
+                expect(utils.getReadOnlyValue(DriverData,"auxClock","apllo")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"auxClock","afvco")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"auxClock","afvcoDiv")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"auxClock","afvcoDivider")).toBe(false);
+                if(device.match("dsPIC33C[A-Z]+[0-9]+M[^C]+[0-9]+$")){
+                    const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                    expect(utils.getSettingBit(PLIBData,"ACLKCON1","FRCSEL")).toBe("Primary Oscillator");
+                    expect(utils.getSettingBit(PLIBData,"ACLKCON1","APLLEN")).toBe("enabled");
+                    expect(utils.getSettingBit(PLIBData,"APLLFBD1","APLLFBDIV")).toBe("48");
+                    expect(utils.getSettingBit(PLIBData,"APLLDIV1","AVCODIV")).toBe("FVCO/2");
+                    expect(utils.getSettingBit(PLIBData,"APLLDIV1","APOST1DIV")).toBe("1:7");
+                    expect(utils.getSettingBit(PLIBData,"APLLDIV1","APOST2DIV")).toBe("1:3");
+                
+                    expect(utils.getRegisterValue(PLIBData,"ACLKCON1")).toBe("ACLKCON1 : 0x8001");
+                    expect(utils.getRegisterValue(PLIBData,"APLLFBD1")).toBe("APLLFBD1 : 0x30");
+                    expect(utils.getRegisterValue(PLIBData,"APLLDIV1")).toBe("APLLDIV1 : 0x273");
+                }
+                },MAX_TESTCASE_TIMEOUT);   
+            test("TID_3-2 For the Auxiliary clock source FRC Oscillator, Verify the Calculated AFPLLO, AFVCO, AFVCODIV and derived Registers settings", async () => {
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','FRC Oscillator');
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','FRC Oscillator')).toBeTruthy();
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                expect(utils.getHiddenProperty(DriverData,"auxClock","auxClockInputFrequency_Hz")).toBe("hidden");
+                expect(utils.getHiddenProperty(DriverData,"auxClock","requestedAuxClockOutputFrequency_Hz")).toBe("hidden");
+                expect(utils.getHiddenProperty(DriverData,"auxClock","afvcoDivider")).toBe("hidden");
+                expect(utils.getHiddenProperty(DriverData,"auxClock","afvco")).toBe("hidden");
+                expect(utils.getHiddenProperty(DriverData,"auxClock","afvcoDiv")).toBe("hidden");
+                
+                if(device.match("dsPIC33C[A-Z]+[0-9]+M[^C]+[0-9]+$")){
+                    const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                    expect(utils.getSettingBit(PLIBData,"ACLKCON1","FRCSEL")).toBe("FRC Oscillator");
+                    expect(utils.getSettingBit(PLIBData,"ACLKCON1","APLLEN")).toBe("disabled");
+                
+                    expect(utils.getRegisterValue(PLIBData,"ACLKCON1")).toBe("ACLKCON1 : 0x101");
+                    expect(utils.getRegisterValue(PLIBData,"APLLFBD1")).toBe("APLLFBD1 : 0x96");
+                    expect(utils.getRegisterValue(PLIBData,"APLLDIV1")).toBe("APLLDIV1 : 0x41");
+                    }
+                
+                },MAX_TESTCASE_TIMEOUT);  
+            test("TID_3-3 For the Auxiliary clock source Primary Oscillator, Verify the Calculated AFPLLO, AFVCO, AFVCODIV and derived Registers settings", async () => {
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','Primary Oscillator');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','Primary Oscillator')).toBeTruthy();
+                    const DriverData = await testAPI.getModuleData(driverModuleId);
+                
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","auxClockArg")?.auxClockSource).toBe("Primary Oscillator");
+                
+                    expect(utils.getReadOnlyValue(DriverData,"auxClock","apllo")).toBe(true);
+                    expect(utils.getReadOnlyValue(DriverData,"auxClock","auxClockInputFrequency_Hz")).toBe(false);
+                    expect(utils.getHiddenProperty(DriverData,"auxClock","requestedAuxClockOutputFrequency_Hz")).toBe("hidden");
+                    expect(utils.getHiddenProperty(DriverData,"auxClock","afvcoDivider")).toBe("hidden");
+                    expect(utils.getHiddenProperty(DriverData,"auxClock","afvco")).toBe("hidden");
+                    expect(utils.getHiddenProperty(DriverData,"auxClock","afvcoDiv")).toBe("hidden");
+                
+                    if(device.match("dsPIC33C[A-Z]+[0-9]+M[^C]+[0-9]+$")){
+                        const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                        expect(utils.getSettingBit(PLIBData,"ACLKCON1","FRCSEL")).toBe("Primary Oscillator");
+                        expect(utils.getSettingBit(PLIBData,"ACLKCON1","APLLEN")).toBe("disabled");
+                        expect(utils.getRegisterValue(PLIBData,"ACLKCON1")).toBe("ACLKCON1 : 0x1");
+                        expect(utils.getRegisterValue(PLIBData,"APLLFBD1")).toBe("APLLFBD1 : 0x96");
+                        expect(utils.getRegisterValue(PLIBData,"APLLDIV1")).toBe("APLLDIV1 : 0x241");
+                    }
+                
+                },MAX_TESTCASE_TIMEOUT); 
+            test("TID_3-4 For the Auxiliary clock source FRC Oscillator with PLL, Verify the Calculated AFPLLO, AFVCO, AFVCODIV and derived Registers settings", async () => {
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','FRC Oscillator with PLL');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockSource','FRC Oscillator with PLL')).toBeTruthy();
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockInputFrequency_Hz','18000000');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','auxClock.auxClockInputFrequency_Hz','18000000')).toBeTruthy();
+                
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','auxClock.afvcoDivider','4');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','auxClock.afvcoDivider','4')).toBeTruthy();
+                    const DriverData = await testAPI.getModuleData(driverModuleId);
+                
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","auxClockArg")?.auxClockSource).toBe("FRC Oscillator with PLL");
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","auxClockArg")?.auxClockInputFrequency_Hz).toBe("18000000");
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","auxClockArg")?.afvcoDivider).toBe(4);
+                    
+                    expect(utils.getReadOnlyValue(DriverData,"auxClock","auxClockInputFrequency_Hz")).toBe(false);
+                    expect(utils.getReadOnlyValue(DriverData,"auxClock","apllo")).toBe(true);
+                    expect(utils.getReadOnlyValue(DriverData,"auxClock","afvco")).toBe(true);
+                    expect(utils.getReadOnlyValue(DriverData,"auxClock","afvcoDiv")).toBe(true);
+                    expect(utils.getReadOnlyValue(DriverData,"auxClock","afvcoDivider")).toBe(false);
+                
+                    if(device.match("dsPIC33C[A-Z]+[0-9]+M[^C]+[0-9]+$")){
+                        const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                        expect(utils.getSettingBit(PLIBData,"ACLKCON1","FRCSEL")).toBe("FRC Oscillator");
+                        expect(utils.getSettingBit(PLIBData,"ACLKCON1","APLLEN")).toBe("enabled");
+                    
+                        expect(utils.getRegisterValue(PLIBData,"ACLKCON1")).toBe("ACLKCON1 : 0x8101");
+                        expect(utils.getRegisterValue(PLIBData,"APLLFBD1")).toBe("APLLFBD1 : 0x30");
+                        expect(utils.getRegisterValue(PLIBData,"APLLDIV1")).toBe("APLLDIV1 : 0x73");
+                    }
+                
+                },MAX_TESTCASE_TIMEOUT); 
+            });
+        }
+    // Reference Clock 
+    describe("TID_4 Reference Clock", () => {
+        test("TID_4-1 Reference Clock with defailt setting", async () => {
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockEnable',false)).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getReadOnlyValue(DriverData,"refClock","refClockSource")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"refClock","requestedRefClockOutputFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROOUT")).toBe("disabled");
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROEN")).toBe("disabled");
+            expect(utils.getSettingBit(PLIBData,"REFOCONH","RODIV")).toBe(0);
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_4-2 Enable reference clock source and check the UI behavior", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockEnable',true);
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockEnable',true)).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getReadOnlyValue(DriverData,"refClock","refClockSource")).toBe(false);
+            expect(utils.getReadOnlyValue(DriverData,"refClock","requestedRefClockOutputFrequency_Hz")).toBe(false);
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);    
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_4-3 For the Reference clock source Primary Oscillator, Verify the  Calculated REFO Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','Primary Oscillator');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','Primary Oscillator')).toBeTruthy();   
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','1000000');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','1000000')).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','1.00 MHz')).toBeTruthy(); 
+    
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("Primary Oscillator");
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.requestedRefClockOutputFrequency_Hz).toBe("1000000");
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+    
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("Primary Oscillator");
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROOUT")).toBe("enabled");
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROEN")).toBe("enabled");
+        
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_4-4 For the Reference clock source REFCLKI, Verify the  Calculated REFO Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','REFCLKI');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','REFCLKI')).toBeTruthy();   
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','8000000');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','8000000')).toBeTruthy();
+    
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','0.00 kHz')).toBeTruthy(); 
+    
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("REFCLKI");
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.requestedRefClockOutputFrequency_Hz).toBe("8000000");
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+            
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("REFCLKI")
+            expect(utils.getRegisterValue(PLIBData,"REFOCONL")).toBe("REFOCONL : 0x9007");
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_4-5 For the Reference clock source FVCO/4, Verify the  Calculated REFO Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FVCO/4');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FVCO/4')).toBeTruthy();   
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','1000000');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','1000000')).toBeTruthy();
+    
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','1.00 MHz')).toBeTruthy(); 
+    
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("FVCO/4");
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.requestedRefClockOutputFrequency_Hz).toBe("1000000");
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+            
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("FVCO/4");
+            expect(utils.getSettingBit(PLIBData,"REFOCONH","RODIV")).toBe(150);
+            expect(utils.getRegisterValue(PLIBData,"REFOCONL")).toBe("REFOCONL : 0x9006");
+            expect(utils.getRegisterValue(PLIBData,"REFOCONH")).toBe("REFOCONH : 0x96");
+            },MAX_TESTCASE_TIMEOUT);
+            // 
+        test("TID_4-6 For the Reference clock source BFRC Oscillator, Verify the  Calculated REFO Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','BFRC Oscillator');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','BFRC Oscillator')).toBeTruthy();   
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','8000000');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','8000000')).toBeTruthy();
+    
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','8.00 MHz')).toBeTruthy(); 
+    
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("BFRC Oscillator");
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.requestedRefClockOutputFrequency_Hz).toBe("8000000");
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+            
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("BFRC Oscillator");
+            expect(utils.getSettingBit(PLIBData,"REFOCONH","RODIV")).toBe(0);
+            expect(utils.getRegisterValue(PLIBData,"REFOCONL")).toBe("REFOCONL : 0x9005");
+            expect(utils.getRegisterValue(PLIBData,"REFOCONH")).toBe("REFOCONH : 0x0");
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_4-7 For the Reference clock source FRC Oscillator, Verify the  Calculated REFO Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FRC Oscillator');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FRC Oscillator')).toBeTruthy();   
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','1000000');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','1000000')).toBeTruthy();
+    
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','1.00 MHz')).toBeTruthy(); 
+    
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("FRC Oscillator");
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.requestedRefClockOutputFrequency_Hz).toBe("1000000");
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+    
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("FRC Oscillator");
+            expect(utils.getSettingBit(PLIBData,"REFOCONH","RODIV")).toBe(4);
+            expect(utils.getRegisterValue(PLIBData,"REFOCONL")).toBe("REFOCONL : 0x9003");
+            expect(utils.getRegisterValue(PLIBData,"REFOCONH")).toBe("REFOCONH : 0x4");
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_4-8 For the Reference clock source FOSC/2, Verify the  Calculated REFO Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FOSC/2');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FOSC/2')).toBeTruthy();   
+            
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','100000');
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','100000')).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','100.00 kHz')).toBeTruthy(); 
+    
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("FOSC/2");
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.requestedRefClockOutputFrequency_Hz).toBe("100000");
+            expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+    
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("FOSC/2");
+            expect(utils.getRegisterValue(PLIBData,"REFOCONL")).toBe("REFOCONL : 0x9001");
+            expect(utils.getRegisterValue(PLIBData,"REFOCONH")).toBe("REFOCONH : 0x14");
+            },MAX_TESTCASE_TIMEOUT);
+            if(device.match("dsPIC33C[A-Z]+[0-9]+M[^C]+[0-9]+")){
+                test("TID_4-9 For the Reference clock source LPRC Oscillator, Verify the  Calculated REFO Frequency", async () => {
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','LPRC Oscillator');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','LPRC Oscillator')).toBeTruthy();   
+                    
+                    await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','13000000');
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','13000000')).toBeTruthy();
+            
+                    expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','32.00 kHz')).toBeTruthy(); 
+            
+                    const DriverData = await testAPI.getModuleData(driverModuleId);
+                    expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("LPRC Oscillator");
+                    expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+                    
+                    const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                    expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("LPRC Oscillator");
+                    expect(utils.getSettingBit(PLIBData,"REFOCONH","RODIV")).toBe(0);
+                    expect(utils.getRegisterValue(PLIBData,"REFOCONL")).toBe("REFOCONL : 0x9004");
+                    expect(utils.getRegisterValue(PLIBData,"REFOCONH")).toBe("REFOCONH : 0x0");
+                    },MAX_TESTCASE_TIMEOUT);
+        }
+            test("TID_4-9 For the Reference clock source FOSC, Verify the  Calculated REFO Frequency", async () => {
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FOSC');
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.refClockSource','FOSC')).toBeTruthy();   
+                
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','120000000');
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.requestedRefClockOutputFrequency_Hz','120000000')).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','refClock.calculatedRefOutputFrequency_Hz','8.00 MHz')).toBeTruthy(); 
+              
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.refClockSource).toBe("FOSC");
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","refClockArg")?.requestedRefClockOutputFrequency_Hz).toBe("120000000");
+                expect(utils.getReadOnlyValue(DriverData,"refClock","calculatedRefOutputFrequency_Hz")).toBe(true);
+        
+                const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                expect(utils.getSettingBit(PLIBData,"REFOCONL","ROSEL")).toBe("FOSC");
+                expect(utils.getSettingBit(PLIBData,"REFOCONH","RODIV")).toBe(0);
+                expect(utils.getRegisterValue(PLIBData,"REFOCONL")).toBe("REFOCONL : 0x9000");
+                expect(utils.getRegisterValue(PLIBData,"REFOCONH")).toBe("REFOCONH : 0x0");
+                },MAX_TESTCASE_TIMEOUT);
+        });
+    describe("TID_5 CAN FD Clock for different clock input source", () => {
+    // dsPIC33CK64MP105,dsPIC33CDV256MP506,dsPIC33CK512MPT608,dsPIC33CDVC256MP506,dsPIC33CK256MP508,dsPIC33CK512MP608,dsPIC33CK1024MP710,dsPIC33CH512MP508,dsPIC33CH128MP508
+    if(device.match("dsPIC33C[A-Z]+[0-9]{3,4}M[^C]+[0-9]{3}$")){
+        test("TID_5-1 CAN FD Clock with default setting", async () => {
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"No Clock Selected")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"0.00 kHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"0.00 kHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"0.00 kHz")).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_5-2 CAN FD Clock source FVCO, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+            const driverInfo = {
+                name: "@mchp-mcc/can-fd-driver",
+                version: ">=1.0.0",
+            };
+
+            const interfaceInfo ={
+                name: "can-fd-interface",
+                version: "1.1.1"
+            };
+            let moduleIds = await testAPI.getModuleIdsforInterface(driverInfo);
+            expect(moduleIds.length).toBeGreaterThan(0);
+            let canmoduleId=moduleIds[0];
+            expect(await testAPI.loadModule(canmoduleId)).toBe(true);
+            const options = await testAPI.getOptionsForImportInterfaceId(canmoduleId, interfaceInfo);
+            if (options.length > 0) {
+                expect(options.length).toBeGreaterThan(0);
+                expect(await testAPI.setImportInterfaceIdByOption(canmoduleId, interfaceInfo, options[0])).toBeTruthy();
+            }
+            expect(await testAPI.loadModule(canmoduleId, MAX_CMD_TIMEOUT)).toBe(true);
+            await testAPI.setAutoModuleProperty(canmoduleId, 'main', 'clockSettings.requestedSpeed', '40.00 MHz');
+            expect (await testAPI.assertAutoModuleProperty(canmoduleId, 'main', 'clockSettings.requestedSpeed', '40.00 MHz')).toBeTruthy();
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO");
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"1200.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("FVCO");
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x811d");
+            expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("FVCO");
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_5-3 CAN FD Clock source FPLLO, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FPLLO");
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FPLLO")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"1200.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("FPLLO");
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x821d");
+            expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("FPLLO");
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_5-4 CAN FD Clock source FVCO/2, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO/2");
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO/2")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"600.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("FVCO/2");
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x830e");
+            expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("FVCO/2");
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_5-5 the CAN FD Clock source FVCO/3, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO/3");
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO/3")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"400.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("FVCO/3");
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x8409");
+            expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("FVCO/3");
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+            },MAX_TESTCASE_TIMEOUT);
+        test("TID_5-6 the CAN FD Clock source FVCO/4, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {   
+            await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO/4");
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"FVCO/4")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"300.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+            expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"37.50 MHz")).toBeTruthy();
+            const DriverData = await testAPI.getModuleData(driverModuleId);
+            expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("FVCO/4");
+            const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+            expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x8507");
+            expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("FVCO/4");
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+            expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+            },MAX_TESTCASE_TIMEOUT);
+        }
+       // dsPIC33CK64MP105,dsPIC33CDV256MP506,dsPIC33CK512MPT608,dsPIC33CDVC256MP506,dsPIC33CK256MP508,dsPIC33CK512MP608,dsPIC33CK1024MP710
+        if(device.match("dsPIC33C[^H]+[0-9]{3,4}M[^C]+[0-9]+$")){
+            test("TID_5-7 CAN FD Clock source AFPLLO, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFPLLO");
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFPLLO")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"18.29 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"18.29 MHz")).toBeTruthy();
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("AFPLLO");
+                const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x8600");
+                expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("AFPLLO");
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+                },MAX_TESTCASE_TIMEOUT);
+        
+            test("TID_5-8 CAN FD Clock source AFVCO, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+                
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO");
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"384.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"38.40 MHz")).toBeTruthy();
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("AFVCO");
+                const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x8709");
+                expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("AFVCO");
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+                },MAX_TESTCASE_TIMEOUT);
+
+            test("TID_5-9 CAN FD Clock source AFVCO/2, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO/2");
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO/2")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"192.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"38.40 MHz")).toBeTruthy();
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("AFVCO/2");
+                const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x8804");
+                expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("AFVCO/2");
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+                },MAX_TESTCASE_TIMEOUT);
+
+            test("TID_5-10 CAN FD Clock source AFVCO/3, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO/3");
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO/3")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"128.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"42.67 MHz")).toBeTruthy();
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("AFVCO/3");
+                const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x8902");
+                expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("AFVCO/3");
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+                },MAX_TESTCASE_TIMEOUT);
+
+            test("TID_5-11 CAN FD Clock source AFVCO/4, Verify the Clock Source Frequency, Requested FCAN Frequency and Calculated FCAN Frequency", async () => {
+                await testAPI.setAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO/4");
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClockSource',"AFVCO/4")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.canfdClkSrcFreq',"96.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.requestedCanfdClockOutputFrequency_Hz',"40.00 MHz")).toBeTruthy();
+                expect(await testAPI.assertAutoModuleProperty(driverModuleId, 'main','canfdClock.calculatedCanfdOutputFrequency_Hz',"48.00 MHz")).toBeTruthy();
+                const DriverData = await testAPI.getModuleData(driverModuleId);
+                expect(utils.getArgs(DriverData,"clock_16bit_config_interface","canfdClockArg")?.canfdClockSource).toBe("AFVCO/4");
+                const PLIBData = await testAPI.getModuleData(PLIBModuleId);
+                expect(utils.getRegisterValue(PLIBData,"CANCLKCON")).toBe("CANCLKCON : 0x8a01");
+                expect(utils.getSettingBit(PLIBData,"CANCLKCON","CANCLKSEL")).toBe("AFVCO/4");
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","canfdClkSrcFreq")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","requestedCanfdClockOutputFrequency_Hz")).toBe(true);
+                expect(utils.getReadOnlyValue(DriverData,"canfdClock","calculatedCanfdOutputFrequency_Hz")).toBe(true);    
+                },MAX_TESTCASE_TIMEOUT);
+        }
+    });
+    describe("TID_6 Generate code and save project", () => {
+        test("TID_6-1 to Generate code and save project with configurations", async () => {
+            expect(await testAPI.generateCode()).toBe(true);
+            const projectName = `${device}.clock.X`;
+            expect(await testAPI.saveProjectAs(projectName, true)).toBe(true);
+        },MAX_TESTCASE_TIMEOUT);
+    }); 
+    });
+});