//***************************************************************************** // (C) Automotive Lighting Reutlingen GmbH // Tuebinger Strasse 123, 72762 Reutlingen, Germany // // Automotive Lighting Reutlingen GmbH owns all the rights to this work. // This work shall not be copied, reproduced, used, modified, transferred // or its information shall not be disclosed without the prior written // authorization of Automotive Lighting Reutlingen GmbH. //***************************************************************************** //----------------------------------------------------------------------------- /// \file Test.c /// /// \brief Unit Test Cases for CddMlc /// /// \author Bodian Bianca Dorina (F31199D) /// mailTo:bianca-dorina.bodian[at]marelli.com //----------------------------------------------------------------------------- //============================================================================================================================================================= // Files covered by this module unit test: // - CddMlcGen.c // - CddMlc.c // - CddMlcUart.c // - ctaaCddMlc.c //============================================================================================================================================================= //============================================================================= // Includes //============================================================================= #include #include #include #include #include #include #include #include #include #include #include #include #include //============================================================================= // #defines //============================================================================= //CddMlcUart.c #define PCLK_SCB3_CLOCK (33U) //Peripheral Clock Assignments #define PCLK_SCB3_DIV_8 (22U) #define CPU_IRQ (6U) #define SYS_INT_NUM (91U) // TPS92662A registers #define _CDD_MLC_REGS_H #define CDD_MLC_N_TX_CFG_PHASE (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_16_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_ICID (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_CFG_CHIP (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_03_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_CFG_STRING (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_12_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_CONFIG (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_RX_CONFIG (CDD_MLC_N_TX_CONFIG+CDD_MLC_N_32_BYTES+CDD_MLC_N_CRC_BYTES) #define CDD_MLC_ACK_BYTE 0x7Fu #define CDD_MLC_N_TX_ADCID (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_01_BYTE + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_DEF_CFG (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_03_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_SSYNC 0u #define CDD_MLC_N_TX_CFG_COM (CDD_MLC_N_TX_ADCID + CDD_MLC_N_TX_DEF_CFG + CDD_MLC_N_TX_SSYNC) #define CDD_MLC_N_TX_FAULT (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_RX_FAULT (CDD_MLC_N_TX_FAULT +CDD_MLC_N_03_BYTES+CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_ADC (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_RX_ADC (CDD_MLC_N_TX_ADC +CDD_MLC_N_02_BYTES+CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_CLRFLT (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_03_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_TX_WIDTH (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_16_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_N_RX_WIDTH (CDD_MLC_N_TX_WIDTH +CDD_MLC_N_ACK) #define RTE_E_OK (uint8)0x00 #define CDD_MLC_LEDS 12u #define CDD_MLC_FAULT_STATUS_INIT 0x0000u //CddMlcI2C.c #if (CDD_MLC_I2C_ENABLED == CDD_MLC_FEATURE_ON) // I2C EEPROM Feature Enabled? #define CDD_MLC_I2C_N_TX_INIT (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_01_BYTE + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_I2C_N_TX_STATUS (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_I2C_N_TX_START (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_04_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_I2C_N_TX_READ_DATA (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_I2C_N_TX_WRITE_DATA (CDD_MLC_N_HEADER_BYTES + CDD_MLC_N_01_BYTE + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_I2C_N_RX_INIT (CDD_MLC_I2C_N_TX_INIT + CDD_MLC_N_ACK) #define CDD_MLC_I2C_N_RX_STATUS (CDD_MLC_I2C_N_TX_STATUS + CDD_MLC_N_01_BYTE + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_I2C_N_RX_START (CDD_MLC_I2C_N_TX_START + CDD_MLC_N_ACK) #define CDD_MLC_I2C_N_RX_READ_DATA (CDD_MLC_I2C_N_TX_READ_DATA + CDD_MLC_N_16_BYTES + CDD_MLC_N_CRC_BYTES) #define CDD_MLC_I2C_N_RX_WRITE_DATA (CDD_MLC_I2C_N_TX_WRITE_DATA+ CDD_MLC_N_ACK) #define CDD_MLC_I2C_RD_STATUS_VALID ((uint8)CDD_MLC_I2CSTAT_BUSYERR | (uint8)CDD_MLC_I2CSTAT_ADRNACK | (uint8)CDD_MLC_I2CSTAT_SDALOW ) #define CDD_MLC_I2C_WR_STATUS_VALID ((uint8)CDD_MLC_I2CSTAT_BUSYERR | (uint8)CDD_MLC_I2CSTAT_ADRNACK | (uint8)CDD_MLC_I2CSTAT_SDALOW | (uint8)CDD_MLC_I2CSTAT_DATNACK) #define CDD_MLC_I2C_DEV_TYPE_ID (0x0AU) #define CDD_MLC_I2C_BLOCK_BITS_MASK (0x06U) #endif #define CDD_MLC_NXP_MAX_SWITCHS_PER_DEVICE 12U //CddMlc.c //#define CDD_MLC_CMD_IDX_READ_CNFG (CDD_MLC_CHIPS) //#define CDD_MLC_CMD_IDX_READ_ADCS (CDD_MLC_CMD_IDX_READ_CNFG + 1U) //#define CDD_MLC_CMD_IDX_READ_FLTS (CDD_MLC_CMD_IDX_READ_ADCS + 1U) //#define CDD_MLC_COMMANDS (CFG_MAX_NO_OF_MLC + 3U) //CddMlc.c enum { CDD_MLC_CMD_IDX_READ_CNFG = CDD_MLC_CHIPS, CDD_MLC_CMD_IDX_READ_ADCS, CDD_MLC_CMD_IDX_READ_FLTS, CDD_MLC_COMMANDS }; //============================================================================= // typedefs //============================================================================= #define __asm(x) //CddMlcI2C.c #if (CDD_MLC_I2C_ENABLED == CDD_MLC_FEATURE_ON) // I2C EEPROM Feature Enabled? typedef enum { //-I2C Communication States- CddMlcI2C_NotInit = 0, // Not Initialized CddMlcI2C_Init, // Initialization Process CddMlcI2C_Idle, // Idle - No operation performed CddMlcI2C_Read_Start, // Read process started CddMlcI2C_Read_Status, // Evaluate reading status CddMlcI2C_Read_Data, // Receive data bytes from FIFO CddMlcI2C_Write_Data, // Send data byte for writing CddMlcI2C_Write_Start, // Write proccess started CddMlcI2C_Write_Status, // Evaluate writing status CddMlcI2C_ControlReset, // Reset I2C state machine and the receive FIFO is flushed CddMlcI2C_Length // Number of I2C states }tCddMlcI2C_eState; typedef void(*tCddMlcI2C_pFnct)(void); // I2C Callback Function Definition typedef struct { //-I2C Function Call State Machine- tCddMlcI2C_eState eState; // Depending of Current State, tCddMlcI2C_pFnct pfnCommand; // a command is prepared and sent, tCddMlcI2C_pFnct pfnHandler; // a handler evaluate the response, tCddMlcI2C_pFnct pfnTimeout; // and update the timeout counters. }tCddMlcI2C_StateTable; #endif //============================================================================= // Global variable stubs ( registers, global variables from other modules which are referenced in the module ) //============================================================================= //CddMlcUart.c //============================================================================= // Global variables (of the module itself) //============================================================================= //CddMlcUart.c extern tCddMlcUart_Message CddMlcUart_Buffer[]; extern volatile boolean CddMlcUart_boIsUartReady; extern boolean CddMlcUart_boRxSuccess; extern uint16 CddMlcUart_unSendReceive_Iterator; extern uint16 CddMlcUart_unAddMessage_Iterator; extern TIMER CddMlcUart_CommandStart; extern boolean boTimeout; extern boolean CddMlcUart_boMsgSent; //CddMlc.c extern uint8 CddMlc_ucClearFaults; extern uint8 CddMlc_ucChipNbr; extern tCddMlc_RegisterConfig CddMlc_ucChipSysConfig_List[CFG_MAX_NO_OF_MLC]; extern tCddMlc_AdcResult CddMlc_sAdcResult_List[CFG_MAX_NO_OF_MLC]; extern tCddMlc_LedStatus CddMlc_LedStatus_List[CFG_MAX_NO_OF_MLC]; extern tCddMlc_ComStatus CddMlc_ComStatus; extern tCddMlc_SystemMode CddMlc_SystemMode; extern tCddMlc_SystemMode CddMlc_LastSystemMode; extern uint8 CddMlc_ucCmdBroadcastCfgComm_List[CDD_MLC_N_TX_CFG_COM]; extern uint8 CddMlc_ucResBroadcastCfgComm_List[CDD_MLC_N_TX_CFG_COM]; extern uint8 CddMlc_ucCmdBroadcastFault_List[CDD_MLC_N_TX_CLRFLT]; extern uint8 CddMlc_ucResBroadcastFault_List[CDD_MLC_N_TX_CLRFLT]; extern uint8 CddMlc_ucCommand_List[CFG_MAX_NO_OF_MLC][CDD_MLC_N_TX_WIDTH]; extern uint8 CddMlc_ucResponse_List[CFG_MAX_NO_OF_MLC][CDD_MLC_N_RX_WIDTH]; extern uint8 CddMlc_ucCmdRdADC_List[CDD_MLC_N_TX_ADC]; extern uint8 CddMlc_ucResRdADC_List[CDD_MLC_N_RX_ADC]; extern uint8 CddMlc_ucCmdRdFault_List[CDD_MLC_N_TX_FAULT]; extern uint8 CddMlc_ucResRdFault_List[CDD_MLC_N_RX_FAULT]; extern uint8 CddMlc_ucCmdRdConfig_List[CDD_MLC_N_TX_CONFIG]; extern uint8 CddMlc_ucResRdConfig_List[CDD_MLC_N_RX_CONFIG]; extern tCddMlcUart_Status *CddMlc_psCommmandStatus[CDD_MLC_COMMANDS]; extern uint16 CddMlc_unTargetLedWidths_List[CFG_MAX_NO_OF_MLC][CDD_MLC_LEDS]; extern uint16 CddMlc_unActualLedWidths_List[CFG_MAX_NO_OF_MLC][CDD_MLC_LEDS]; extern uint8 CddMlc_ucConfigSlwrate_List[CFG_MAX_NO_OF_MLC]; extern uint8 CddMlc_ucConfigOVLimit_List[CFG_MAX_NO_OF_MLC]; extern uint8 CddMlc_ucConfigParaLed_List[CFG_MAX_NO_OF_MLC]; extern uint8 CddMlc_ucDefaultWidths_List[CFG_MAX_NO_OF_MLC][CDD_MLC_LEDS]; extern uint16 CddMlc_unPhaseShift_List[CFG_MAX_NO_OF_MLC][CDD_MLC_LEDS]; extern uint8 CddMlc_ucDevIdTable_List[CFG_MAX_NO_OF_MLC] = { 0u }; extern uint8 CddMlc_ucDevIdTableIdx_List[CFG_MAX_NO_OF_MLC];// = { 0u }; extern uint8 CddMlc_aucAddress[CFG_MAX_NO_OF_ADDRS_MLC];// = { CDD_MLC_DEV_ID00 , CDD_MLC_DEV_ID01, CDD_MLC_DEV_ID02, CDD_MLC_DEV_ID03, CDD_MLC_DEV_ID04, CDD_MLC_DEV_ID05, CDD_MLC_DEV_ID06, CDD_MLC_DEV_ID07 }; //extern tsCddMlcGenCodingData CddMlcGenCodingDataValue; extern sCddMlcGenCodingData CddMlcGenCodingDataValue; extern boolean CddMlcTI_boBusComError; extern boolean CddMlcTI_boDeviceResponse[CFG_MAX_NO_OF_MLC]; // mark the chip responded with ACK byte //CddMlcI2C.c #if (CDD_MLC_I2C_ENABLED == CDD_MLC_FEATURE_ON) // I2C EEPROM Feature Enabled? extern uint8 CddMlcI2C_ucCmdInit_List[]; extern uint8 CddMlcI2C_ucResInit_List[]; extern uint8 CddMlcI2C_ucCmdStart_List[]; extern uint8 CddMlcI2C_ucResStart_List[]; extern uint8 CddMlcI2C_ucCmdStatus_List[]; extern uint8 CddMlcI2C_ucResStatus_List[]; extern uint8 CddMlcI2C_ucCmdReadData_List[]; extern uint8 CddMlcI2C_ucResReadData_List[]; extern uint8 CddMlcI2C_ucCmdWriteData_List[]; extern uint8 CddMlcI2C_ucResWriteData_List[]; extern uint8* CddMlcI2C_ucPtrReadData; extern uint8* CddMlcI2C_ucPtrWriteData; extern tCddMlcUart_Status* CddMlcI2C_psCommmandStatus; extern tCddMlcI2C_pFnct CddMlcI2C_pfnInitSuccessClbk; extern tCddMlcI2C_pFnct CddMlcI2C_pfnInitFailedClbk; extern tCddMlcI2C_pFnct CddMlcI2C_pfnWriteSuccessClbk; extern tCddMlcI2C_pFnct CddMlcI2C_pfnWriteFailedClbk; extern tCddMlcI2C_pFnct CddMlcI2C_pfnReadSuccessClbk; extern tCddMlcI2C_pFnct CddMlcI2C_pfnReadFailedClbk; extern uint16 CddMlcI2C_unWriteStartAddress; extern uint16 CddMlcI2C_unWriteEndAddress; extern uint16 CddMlcI2C_unReadStartAddress; extern uint16 CddMlcI2C_unReadEndAddress; extern uint8 CddMlcI2C_ucReadBytesLeft; extern uint8 CddMlcI2C_ucCmdReadData_RxLength; extern tCddMlcI2C_eState CddMlcI2C_State; extern uint8 CddMlcI2C_ucInitTimeoutCounter; extern uint8 CddMlcI2C_ucReadTimeoutCounter; extern uint8 CddMlcI2C_ucWriteTimeoutCounter; extern tCddMlcI2C_eStatus CddMlcI2C_InitStatus; extern tCddMlcI2C_eStatus CddMlcI2C_ReadStatus; extern tCddMlcI2C_eStatus CddMlcI2C_WriteStatus; extern tCddMlcI2C_StateTable CddMlcI2C_StateTable[]; #endif //ctscCddMlc.c extern boolean CddMlc_boInitialized; //CddMlcGen.c //extern tsRteCodingParameters applicationCodingData; extern eCddMlcGenDeviceType CddMlcGen_eConnectedDevice; extern boolean CddMlc_boActionToExecuteAfterNewConfig; extern boolean CddMlc_boOperationEnabled; extern uint8 CddMlc_ucCycleFrame; extern tisMlcSensorInput CddMlcGen_Sensor[CFG_MAX_NO_OF_MLC]; extern tisMxMlcStatusFault CddMlc_asDeviceStatusFault[CFG_MAX_NO_OF_MLC] ; // Refers to MLC Device extern tsCddMlcRegReadRequestHandler CddMlc_sRegReadRequestHandler ; //============================================================================= // Function declarations (of the module itself) //============================================================================= //CddMlcUart.c extern void CddMlcUart_Init(void); extern void CddMlcUart_ErrorHandling(void); extern void CddMlcUart_SendReceived_Irq(void); extern void CddMlcUart_StartSend(void); extern void CddMlcUart_CommLossHandling(void); extern tCddMlcUart_Status* CddMlcUart_AddMessage(uint8* pucTxBuffer, uint8 ucTxLength, uint8* pucRxBuffer, uint8 ucRxLength); extern void CddMlcUart_CommandReset(void); extern void CddMlcUart_ControlUartCommunication(boolean boSetUartState); extern void CddMlcUart_MaskUartInterrupt(void); extern void CddMlcUart_UnmaskUartInterrupt(void); extern void CddMlcUart_ReadRxFifo(uint8* pRxData); extern void CddMlcUart_FillTxFifo(uint8* pData, uint8 size); //CddMlc.c extern void CddMlc_Init(void); extern void CddMlc_Cycle(void); extern void CddMlc_RteSync(void); extern void CddMlc_SetTransmissionActive(boolean boDriverActive); extern void CddMlc_SetTransmissionToInactive(void); extern void CddMlc_SetTransmissionToNormal(void); extern void CddMlc_GetMlcPhysicalAddress(void); #if 0 extern uint8 CddMlc_GetMlcIndexNumber(uint8 address); #endif extern void CddMlc_SetTargetValues(uint8 ucDevNbr, uint16 unTargetWidths_List[]); extern void CddMlc_GetActualValues(uint8 ucDevNbr, uint16 unActualWidths_List[]); extern tCddMlc_RegisterConfig CddMlc_GetChipConfig(uint8 ucDevNbr); extern void CddMlc_Add_CRC(uint8 *ucPtrData, uint8 ucLength); extern void CddMlc_BroadcastComm(void); extern void CddMlc_WriteCfgChips(void); extern void CddMlc_WriteCfgPhases(void); extern void CddMlc_WriteCfgLeds(void); extern void CddMlc_WritePWMs(void); extern void CddMlc_MuxCommands(void); extern void CddMlc_ClearLedsStatus(void); extern void CddMlc_ResetMlcSettings(void); extern void CddMlc_ResetVars(void); extern tCddMlc_SystemMode CddMlc_GetActualState(void); extern tCddMlc_ComStatus CddMlc_GetComStatus(void); extern tCddMlc_AdcResult CddMlc_GetADCResult(uint8 ucDevNbr); extern tCddMlc_LedStatus CddMlc_GetLedsStatus(uint8 ucDevNbr); extern void CddMlc_InterpretResponses(void); extern void CddMlc_StepToNextChip(void); extern void CddMlc_CommandSuccess(uint8 ucCmdIdx); extern void CddMlc_CommandFailed(uint8 ucCmdIdx); extern void CddMlc_ResponseHandler(uint8 ucDevNbr); extern void CddMlc_ScheduleCommands(void); extern uint16* CddMlc_GetTargetBufAddress(void); //CddMlcI2C.c #if (CDD_MLC_I2C_ENABLED == CDD_MLC_FEATURE_ON) // I2C EEPROM Feature Enabled? extern void CddMlcI2C_CommandInit(void); extern void CddMlcI2C_CommandReadStart(void); extern void CddMlcI2C_CommandWriteStart(void); extern void CddMlcI2C_CommandResetStart(void); extern void CddMlcI2C_CommandReadData(void); extern void CddMlcI2C_CommandWriteData(void); extern void CddMlcI2C_CommandControl(boolean boReadOperation, boolean boResetControl); extern void CddMlcI2C_CommandGetStatus(void); extern void CddMlcI2C_StateMachine(void); extern void CddMlcI2C_HandleResults(void); extern void CddMlcI2C_HandleInit(void); extern void CddMlcI2C_HandleStart(void); extern void CddMlcI2C_HandleReadingStatus(void); extern void CddMlcI2C_HandleWritingStatus(void); extern void CddMlcI2C_HandleReadData(void); extern void CddMlcI2C_HandleWriteData(void); extern void CddMlcI2C_TimeoutInit(void); extern void CddMlcI2C_TimeoutRead(void); extern void CddMlcI2C_TimeoutWrite(void); extern void CddMlcI2C_CallbackFunction(tCddMlcI2C_pFnct pFct); extern void CddMlcI2C_CallbackFunction(tCddMlcI2C_pFnct pFct); extern tCddMlcI2C_eStatus* CddMlcI2C_StartInit(tCddMlcI2C_pFnct pfnInitSuccessClbk, tCddMlcI2C_pFnct pfnInitFailedClbk); extern tCddMlcI2C_eStatus* CddMlcI2C_ReadEeprom(uint8 *ucData_List, uint16 unStartAddress, uint16 unLength, tCddMlcI2C_pFnct pfnReadSuccessClbk, tCddMlcI2C_pFnct pfnReadFailedClbk); extern tCddMlcI2C_eStatus* CddMlcI2C_WriteEeprom(uint8 *ucData_List, uint16 unStartAddress, uint16 unLength, tCddMlcI2C_pFnct pfnWriteSuccessClbk, tCddMlcI2C_pFnct pfnWriteFailedClbk); #endif //ctscCddMlc.c extern void CddMlc_RteWrite_SystemMode(tCddMlc_SystemMode *psSysMode); extern void CddMlc_RteWrite_ComStatus(tCddMlc_ComStatus *psComStatus); extern void CddMlc_RteWrite_LedStatus(tCddMlc_LedStatus *psLedStatus); extern void CddMlc_RteWrite_AdcResult(tCddMlc_AdcResult *psAdcResult); extern void CddMlc_RteRead_TgtLedPwms(uint16 *punTgtLedPwms); //extern void CddMlc_RteWrite_CrcErrorStatus(uint8* pucCrcErrorStatus); //CddMlcGen.c extern void CddMlc_UpdateRuntimeStatus(void); extern void CddMlc_UpdateInitStatus(void); extern void CddMlcGen_Init(eCddMlcGenDeviceType eDeviceId); extern void CddMlcGen_Cyclic(eCddMlcGenDeviceType eDeviceId); extern eCddMlcGenDeviceType CddMlcGen_GetCodingParam(void); extern void CddMlc_EvaluateCoding(void); extern uint16* CddMlcGen_GetTargetBufAddress(void); extern void CddMlcGen_SetTransmissionToInactive(void); extern void CddMlcGen_SetTransmissionToNormal(void); extern uint16 CddMlcGen_ConvertToRawValue(uint16 unValueInPercent); extern uint16 CddMlcGen_ConvertDiagToRawValue(uint16 unValueInPercent); extern void riCddMlcDeInit(void); extern void riCddMlcInit(void); extern void CddMlc_ProvideReadAdrInfo(void); //CddMlcRteAccess extern void CddMlc_Rte_Write_MxSwitchAndSensorStatus(tisMxMlcStatusFault* psStatusFault, tisMlcSensorInput* psSensorInput, tieError tCommError, tieStatusOnOff eMlcComStatus); //============================================================================= // Function parameter stubs (of the module ifself) //============================================================================= //CddMlcUart.c uint8* CddMlcUart_AddMessage_Param1; uint8 CddMlcUart_AddMessage_Param2; uint8* CddMlcUart_AddMessage_Param3; uint8 CddMlcUart_AddMessage_Param4; boolean CddMlcUart_ControlUartCommunication_Param1; uint8* CddMlcUart_ReadRxFifo_Param1; uint8* CddMlcUart_FillTxFifo_Param1; uint8 CddMlcUart_FillTxFifo_Param2; //CddMlc.c boolean CddMlc_SetTransmissionActive_Param1; uint8 CddMlc_SetTargetValues_Param1; uint16 CddMlc_SetTargetValues_Param2[CDD_MLC_LEDS]; uint8 CddMlc_GetActualValues_Param1; uint16 CddMlc_GetActualValues_Param2[CDD_MLC_LEDS]; uint8 CddMlc_GetChipConfig_Param1; uint8 CddMlc_Add_CRC_Param1; uint8 CddMlc_Add_CRC_Param2; uint8 CddMlc_GetADCResult_Param1; uint8 CddMlc_GetLedsStatus_Param1; uint8 CddMlc_CommandSuccess_Param1; uint8 CddMlc_CommandFailed_Param1; uint8 CddMlc_ResponseHandler_Param1; #if 0 uint8 CddMlc_GetMlcIndexNumber_Param1; #endif //CddMlcGen.c eCddMlcGenDeviceType CddMlcGen_Init_Param1; eCddMlcGenDeviceType CddMlcGen_Cyclic_Param1; uint16 CddMlcGen_ConvertToRawValue_Param1; uint16 CddMlcGen_ConvertDiagToRawValue_Param1; //ctscCddMlc.c tCddMlc_SystemMode CddMlc_RteWrite_SystemMode_Param1; tCddMlc_ComStatus CddMlc_RteWrite_ComStatus_Param1; tCddMlc_LedStatus CddMlc_RteWrite_LedStatus_Param1; tCddMlc_AdcResult CddMlc_RteWrite_AdcResult_Param1; uint16* CddMlc_RteRead_TgtLedPwms_Param1; uint8* CddMlc_RteWrite_CrcErrorStatus_Param1; //CddI2C.c #if (CDD_MLC_I2C_ENABLED == CDD_MLC_FEATURE_ON) // I2C EEPROM Feature Enabled? tCddMlcI2C_pFnct CddMlcI2C_CallbackFunction_Param1; tCddMlcI2C_pFnct CddMlcI2C_StartInit_Param1; //pfnInitSuccessClbk tCddMlcI2C_pFnct CddMlcI2C_StartInit_Param2; //pfnInitFailedClbk uint8* CddMlcI2C_ReadEeprom_Param1; uint16 CddMlcI2C_ReadEeprom_Param2; uint16 CddMlcI2C_ReadEeprom_Param3; tCddMlcI2C_pFnct CddMlcI2C_ReadEeprom_Param4; //pfnReadSuccessClbk tCddMlcI2C_pFnct CddMlcI2C_ReadEeprom_Param5; //pfnReadFailedClbk uint8* CddMlcI2C_WriteEeprom_Param1; uint16 CddMlcI2C_WriteEeprom_Param2; uint16 CddMlcI2C_WriteEeprom_Param3; tCddMlcI2C_pFnct CddMlcI2C_WriteEeprom_Param4; //pfnWriteSuccessClbk tCddMlcI2C_pFnct CddMlcI2C_WriteEeprom_Param5; //pfnWriteFailedClbk #endif //============================================================================= // Function return value stubs (of the module ifself) //============================================================================= tCddMlcUart_Status* CddMlcUart_AddMessage_RetVal; #if (CDD_MLC_I2C_ENABLED == CDD_MLC_FEATURE_ON) // I2C EEPROM Feature Enabled? tCddMlcI2C_eStatus* CddMlcI2C_StartInit_RetVal; tCddMlcI2C_eStatus* CddMlcI2C_ReadEeprom_RetVal; tCddMlcI2C_eStatus* CddMlcI2C_WriteEeprom_RetVal; #endif tCddMlc_SystemMode CddMlc_GetActualState_RetVal; tCddMlc_ComStatus CddMlc_GetComStatus_RetVal; tCddMlc_RegisterConfig CddMlc_GetChipConfig_RetVal; tCddMlc_AdcResult CddMlc_GetADCResult_RetVal; tCddMlc_LedStatus CddMlc_GetLedsStatus_RetVal; uint16* CddMlc_GetTargetBufAddress_RetVal; #if 0 uint8 CddMlc_GetMlcIndexNumber_RetVal; #endif //CddMlcGen.c eCddMlcGenDeviceType CddMlcGen_GetCodingParam_RetVal; uint16* CddMlcGen_GetTargetBufAddress_RetVal; uint16 CddMlcGen_ConvertToRawValue_RetVal; uint16 CddMlcGen_ConvertDiagToRawValue_RetVal; //============================================================================= // Stub function declarations //============================================================================= //CddMlcUart.c //ctscCddMlc.c //CddMlcI2C.c void Mt_CddMlc_CddMlcI2C_CallbackFunction_Stub(void); void Mt_CddMlc_CddMlcI2C_StartInit_Stub(void); //Rte_Cfg.h //Std_ReturnType Rte_Read_CodM_CddMlc_Para(tsRteCodingParameters* ppara1); Dio_LevelType Dio_ReadChannel(Dio_ChannelType ChannelId); void Gpt_StartTimer(Gpt_ChannelType Channel, Gpt_ValueType Value); Gpt_ValueType Gpt_GetTimeElapsed(Gpt_ChannelType Channel); //============================================================================= // Stub function parameter stubs //============================================================================= //CddmlcI2C.c boolean CddMlcI2C_CommandControl_Param1; //boReadOperation boolean CddMlcI2C_CommandControl_Param2; //boResetControl Dio_ChannelType Dio_ReadChannel_Param1; uint32 LPTMR0_GetTimeElapsed_Param1; Gpt_ChannelType Gpt_StartTimer_Param1; Gpt_ValueType Gpt_StartTimer_Param2; Gpt_ValueType Gpt_GetTimeElapsed_Param1; //============================================================================= // Global variables stubs //============================================================================= tCddMlcUart_Status CddMlc_CommandStatusTemp[CDD_MLC_COMMANDS]; uint16 unTargetWidths_List[12] = { 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu }; uint16 unActualWidths_List[12] = { 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu, 0x3FFu }; tRomPara_CodingArea applicationCodingData; tieDataStatus eCodingPrevStatus; //static inside the function uint8 CddMlcGen_ucPowerUpGuard; //static inside the function boolean CddMlcGen_boMlcPoweredUP; //static inside the function //CddMlcNxp.c uint8 ucComErrorDebouncing[CFG_MAX_NO_OF_MLC]; //static inside the function uint8 ucTimeGuardCnt; //static inside the function //============================================================================= // Stub function returned value stubs //============================================================================= //CddMlcUart.c Dio_LevelType Dio_ReadChannel_RetVal; Gpt_ValueType Gpt_GetTimeElapsed_RetVal; //ctscCddMlc.c //============================================================================= // Stub function hit count variables //============================================================================= uint8 CddMlcI2C_CallbackFunction_Stub_HitCount; uint8 CddMlcI2C_StartInit_Stub_HitCount; uint8 Dio_ReadChannel_HitCount; uint8 Gpt_StartTimer_HitCount; uint8 Gpt_GetTimeElapsed_HitCount; //============================================================================= // Stub function definitions //============================================================================= //----------------------------------------------------------------------------- /// \brief Gpt_StartTimer /// /// \descr Stub function created to simulate the behaviour of Gpt_StartTimer /// /// \param Channel, Value /// /// \return void //----------------------------------------------------------------------------- void Gpt_StartTimer(Gpt_ChannelType Channel, Gpt_ValueType Value) { Gpt_StartTimer_Param1 = Channel; Gpt_StartTimer_Param2 = Value; Gpt_StartTimer_HitCount++; } //----------------------------------------------------------------------------- /// \brief Gpt_GetTimeElapsed /// /// \descr Stub function created to simulate the behaviour of Gpt_StartTimer /// /// \param Channel /// /// \return void //----------------------------------------------------------------------------- Gpt_ValueType Gpt_GetTimeElapsed(Gpt_ChannelType Channel) { Gpt_GetTimeElapsed_Param1 = Channel; Gpt_GetTimeElapsed_HitCount++; return Gpt_GetTimeElapsed_RetVal; } //----------------------------------------------------------------------------- /// \brief Dio_ReadChannel /// /// \descr Stub function created to simulate the behaviour of Dio_ReadChannel /// /// \param ChannelId /// /// \return Dio_LevelType //----------------------------------------------------------------------------- Dio_LevelType Dio_ReadChannel(Dio_ChannelType ChannelId) { Dio_ReadChannel_Param1 = ChannelId; Dio_ReadChannel_HitCount++; return Dio_ReadChannel_RetVal; } //----------------------------------------------------------------------------- /// \brief Rte_Write_ctadCddMlc_ppaseCddMlcMxSwitchAndSensorStatus0_sAllMlcSwitchAndAllSensorStatus /// /// \descr Stub function created to simulate the behaviour of /// Rte_Write_ctadCddMlc_ppaseCddMlcMxSwitchAndSensorStatus0_sAllMlcSwitchAndAllSensorStatus /// /// \return Std_ReturnType //----------------------------------------------------------------------------- STATIC_AL VAR(tisAllMlcSwitchAndAllSensorStatus, RTE_DATA) Rte_GstppareCddMlcMxSwitchAndSensorStatus0_sAllMlcSwitchAndAllSensorStatus_ctaaSysMon = Rte_GstppareCddMlcMxSwitchAndSensorStatus0_sAllMlcSwitchAndAllSensorStatus_ctaaSysMon_Init_DEF; STATIC_AL VAR(tisAllMlcTargets, RTE_VAR_INIT) Rte_GstppareSysMonMxTarget0_sAllMlcTargets_ctadCddMlc = Rte_GstppareSysMonMxTarget0_sAllMlcTargets_ctadCddMlc_Init_DEF; FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctadCddMlc_ppaseCddMlcMxSwitchAndSensorStatus0_sAllMlcSwitchAndAllSensorStatus (P2CONST(tisAllMlcSwitchAndAllSensorStatus, AUTOMATIC, RTE_APPL_DATA) Data) { //VAR(Std_ReturnType, RTE_DATA) LddRetVal; //LddRetVal = RTE_E_OK; //(void)Rte_Memcpy(&Rte_GstppareCddMlcMxSwitchAndSensorStatus0_sAllMlcSwitchAndAllSensorStatus_ctaaSysMon, Data, sizeof(tisAllMlcSwitchAndAllSensorStatus)); //return LddRetVal; return RTE_E_OK; } FUNC(void, OS_CODE) SuspendAllInterrupts(void) { } FUNC(void, OS_CODE) ResumeAllInterrupts(void) { } FUNC(void, RTE_CODE) Rte_Memcpy (void * LpDestination, const void * LpSource, uint32 LulDataSize) { uint32 LulIndex; uint8* LpDest = (uint8*)LpDestination; const uint8* LpSrc = (const uint8*)LpSource; if ((NULL != LpDest) && (NULL != LpSrc)) { for (LulIndex = 0; LulIndex < LulDataSize; LulIndex++) { LpDest[LulIndex] = LpSrc[LulIndex]; } } } FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctadCddMlc_ppareSysMonMxTarget0_sAllMlcTargets (P2VAR(tisAllMlcTargets, AUTOMATIC, RTE_APPL_DATA)Data) { VAR(Std_ReturnType, RTE_DATA) LddRetVal; LddRetVal = RTE_E_OK; (void)Rte_Memcpy(Data, &(Rte_GstppareSysMonMxTarget0_sAllMlcTargets_ctadCddMlc), sizeof(tisAllMlcTargets)); return LddRetVal; } FUNC(uint32, ctadCddMlc_CODE) E2EPW_Read_ctadCddMlc_ppareSysMonMxTarget0_sAllMlcTargets(P2VAR(tisAllMlcTargets, AUTOMATIC, APPL_DATA)sAllMlcTargets) { uint32 RetVal = E2E_P_OK; if (NULL_PTR != sAllMlcTargets) { (void)Rte_Read_ppareSysMonMxTarget0_sAllMlcTargets(sAllMlcTargets); } return RetVal; } //----------------------------------------------------------------------------- /// \brief Mt_CddMlc_CddMlcI2C_CallbackFunction_Stub /// /// \descr Stub function created to simulate the behaviour of CddMlcI2C_CallbackFunction /// /// \return void //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcI2C_CallbackFunction_Stub() { CddMlcI2C_CallbackFunction_Stub_HitCount++; } //----------------------------------------------------------------------------- /// \brief Mt_CddMlc_CddMlcI2C_StartInit_Stub /// /// \descr Stub function created to simulate the behaviour of CddMlcI2C_StartInit_Stub /// /// \return void //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcI2C_StartInit_Stub() { CddMlcI2C_StartInit_Stub_HitCount++; } //============================================================================= // Test Cases //============================================================================= //----------------------------------------------------------------------------- // CddMlc.c //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResetMlcSettings_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that the function CddMlc_ResetMlcSettings sets the /// correct value of internal variable for System Mode handling /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResetMlcSettings_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlc_SystemMode = CddMlc_SystemMode_Powerup; //Step 3) Call FUT CddMlc_ResetMlcSettings(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgComm, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ClearLedsStatus_TestCase /// /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that the function triggers reseting of LED Fault Status registers /// and CRC Error Count Registers for all Mlc chips /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ClearLedsStatus_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlc_ucClearFaults = CDD_MLC_CFG_CLR_FLT_CNT; for (uint8 ucDevNbr = 0u; ucDevNbr < CDD_MLC_CHIPS; ucDevNbr++) { //Step 3) Call FUT CddMlc_ClearLedsStatus(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_LedStatus_List[ucDevNbr].unLedFault, CDD_MLC_FAULT_STATUS_INIT, == ); } AL_UNITTEST_CHECK(CddMlc_ucClearFaults, CDD_MLC_CFG_CLR_FLT_CNT, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_SetTransmissionToNormal_TestCase /// /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that the function CddMlc_SetTransmissionToNormal /// sets the current System mode to Configure Communication mode /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// -Inputs: /// - CddMlc_SystemMode = CddMlc_SystemMode_Powerup /// - Expected results : /// - CddMlc_SystemMode = CddMlc_SystemMode_CfgComm //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_SetTransmissionToNormal_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_SystemMode = CddMlc_SystemMode_Powerup; //Step 3) Call FUT CddMlc_SetTransmissionToNormal(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgComm, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_SetTransmissionToInactive_TestCase /// /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that the function CddMlc_SetTransmissionToInactive /// sets the current system mode to Inactive Sytem mode /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// -Inputs: /// - CddMlc_SystemMode = CddMlc_SystemMode_Powerup /// - Expected results : /// - CddMlc_SystemMode = CddMlc_SystemMode_Inactive //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_SetTransmissionToInactive_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_SystemMode = CddMlc_SystemMode_Powerup; //Step 3) Call FUT CddMlc_SetTransmissionToInactive(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_Inactive, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_SetTransmissionActive_TestCase /// /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that the function CddMlc_SetTransmissionActive sets the Mlc transmission to desired state /// /// - Test Design Technique: DT (Decision Table) /// The Decision Table asTestCaseData[] is used in this test case. This DT contains all possible values of all inputs /// which are taken into account by the algorithm of the FUT, as well as the expected values of all outputs which are /// set by the FUT. /// - DT-Info: /// - Inputs: /// boDriverActive : known value of driver active flag before calling FUT /// //actualState : known value of internal variable before calling FUT /// - Expected results /// returnedState : expected return value by the FUT /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_SetTransmissionActive_TestCase(void) { typedef struct tsTestCaseDataInput { boolean boDriverActive; // tCddMlc_SystemMode actualState; }tsTestCaseDataInput; typedef struct tsTestCaseDataOutput { tCddMlc_SystemMode returnedState; }tsTestCaseDataOutput; typedef struct tsTestCaseData { tsTestCaseDataInput sInputData; tsTestCaseDataOutput sOutputData; }tsTestCaseData; tsTestCaseData asTestCaseData[] = { // Inputs || Outputs // boDriverActive actual state || returned state { { TRUE/*, CddMlc_SystemMode_Powerup*/ } , {CddMlc_SystemMode_CfgComm } }, { { FALSE/*, CddMlc_SystemMode_CfgComm */ } , {CddMlc_SystemMode_Inactive } }, }; for (uint8 ucIdx = 0; ucIdx < sizeof(asTestCaseData) / sizeof(tsTestCaseData); ucIdx++) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlc_SetTransmissionActive_Param1 = asTestCaseData[ucIdx].sInputData.boDriverActive; //Step 3) Call FUT CddMlc_SetTransmissionActive(CddMlc_SetTransmissionActive_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, asTestCaseData[ucIdx].sOutputData.returnedState, == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResetVars_TestCase /// /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that the function initializes internal variables such as /// Communication Status, LED Fault Status and ADC Results /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResetVars_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values //Init Global Communication Status for each Mlc device CddMlc_ComStatus.ulMlcStatus = 0x7Fu; //Init Global Power Cycle Flag for each Mlc device CddMlc_ComStatus.ulPowerCycleOccurred = 0x7Fu; //Init UART Communication Errors Occurrence Counter CddMlc_ComStatus.ulUartErrorsOccurred = 0x7Fu; //Init Tx Overrun Counter CddMlc_ComStatus.ulTxCommandOverrun = 0x7Fu; //Init the Variant Chip Settings flag CddMlc_ComStatus.ulAckChipSetting = 0x7Fu; //Init the Variant Phase Shifts flag CddMlc_ComStatus.ulAckPhaseShifts = 0x7Fu; //Init the Variant LED Segments flag CddMlc_ComStatus.ulAckLedSegments = 0x7Fu; CddMlc_sAdcResult_List[0].ucADC1Value = 255u; CddMlc_sAdcResult_List[0].ucADC2Value = 255u; CddMlc_sAdcResult_List[0].eQlty = CDD_MLC_QLTY_SNA; CddMlc_LedStatus_List[0].unLedFault = 0xFFFF; CddMlc_ComStatus.ucTimeoutCounter_List[0] = 30u; //Step 3) Call FUT CddMlc_ResetVars(); //Step 4) Check expected output values for (uint8 ucDevNbr = 0u; ucDevNbr < CDD_MLC_CHIPS; ucDevNbr++) { AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[ucDevNbr].ucADC1Value, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[ucDevNbr].ucADC2Value, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[ucDevNbr].eQlty, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_LedStatus_List[ucDevNbr].unLedFault, 0x0000u, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ucMatrixIcID_List[ucDevNbr], 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ucTimeoutCounter_List[ucDevNbr], 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ucCrcFltOccurrence_List[ucDevNbr], 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].SLEWRATE, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].OVLMT, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].PARLED, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].DEFWIDTH02_01, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].DEFWIDTH04_03, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].DEFWIDTH06_05, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].DEFWIDTH08_07, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].DEFWIDTH10_09, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].DEFWIDTH12_11, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].SYSCFG, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].CMWTAP, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].PWMTICK, 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[ucDevNbr].ADCID, 0x00u, == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetActualState_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: /// Check if the function CddMlc_GetActualState returns the correct variable of one internal variable /// /// - Test Design Technique: DT (Decision Table) /// The Decision Table asTestCaseData[] is used in this test case. This DT contains all possible values of all inputs /// which are taken into account by the algorithm of the FUT, as well as the expected values of all outputs which are /// set by the FUT. /// - DT-Info: /// - Inputs: /// actualState : known value of internal variable before calling FUT /// - Expected results /// returnedState : expected return value by the FUT /// /// For further information about specific input/outputs variables refer to the input assignament (step 2) and output value check (step 4) of this Unit Test Case /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetActualState_TestCase(void) { typedef struct tsTestCaseDataInput { tCddMlc_SystemMode actualState; }tsTestCaseDataInput; typedef struct tsTestCaseDataOutput { tCddMlc_SystemMode returnedState; }tsTestCaseDataOutput; typedef struct tsTestCaseData { tsTestCaseDataInput sInputData; tsTestCaseDataOutput sOutputData; }tsTestCaseData; tsTestCaseData asTestCaseData[] = { // Inputs || Outputs // actual state || returned state { { CddMlc_SystemMode_Powerup } , {CddMlc_SystemMode_Powerup } }, { { CddMlc_SystemMode_CfgComm } , {CddMlc_SystemMode_CfgComm } }, { { CddMlc_SystemMode_CfgChips } , {CddMlc_SystemMode_CfgChips } }, { { CddMlc_SystemMode_CfgPhases } , {CddMlc_SystemMode_CfgPhases } }, { { CddMlc_SystemMode_CfgLeds } , {CddMlc_SystemMode_CfgLeds } }, { { CddMlc_SystemMode_ClrFlts } , {CddMlc_SystemMode_ClrFlts } }, { { CddMlc_SystemMode_Normal } , {CddMlc_SystemMode_Normal } }, { { CddMlc_SystemMode_Inactive } , {CddMlc_SystemMode_Inactive } }, { { CddMlc_SystemMode_Length } , {CddMlc_SystemMode_Length } }, }; for (uint8 ucIdx = 0; ucIdx < sizeof(asTestCaseData) / sizeof(tsTestCaseData); ucIdx++) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlc_SystemMode = asTestCaseData[ucIdx].sInputData.actualState; //Step 3) Call FUT CddMlc_GetActualState_RetVal = CddMlc_GetActualState(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_GetActualState_RetVal, asTestCaseData[ucIdx].sOutputData.returnedState, == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetActualValues_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function stores the LED intensities for the current Mlc chip /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetActualValues_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_GetActualValues_Param1 = 1u; for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_CHIPS; ucIdx++) { for (uint8 ucSegNbr = 0u; ucSegNbr < CDD_MLC_LEDS; ucSegNbr++) { CddMlc_unActualLedWidths_List[ucIdx][ucSegNbr] = unActualWidths_List[ucIdx]; } } //Step 3) Call FUT CddMlc_GetActualValues(CddMlc_GetActualValues_Param1, CddMlc_GetActualValues_Param2); //Step 4) Check expected output values for (uint8 ucSegNbr = 0u; ucSegNbr < CDD_MLC_LEDS; ucSegNbr++) { AL_UNITTEST_CHECK(CddMlc_GetActualValues_Param2[ucSegNbr], CddMlc_unActualLedWidths_List[1][ucSegNbr], == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetChipConfig_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function returns the Chip Register Configuration of selected Mlc device /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetChipConfig_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_GetChipConfig_Param1 = 1u; CddMlc_ucChipSysConfig_List[CddMlc_GetChipConfig_Param1].SLEWRATE = 5u; //Step 3) Call FUT CddMlc_GetChipConfig_RetVal = CddMlc_GetChipConfig(CddMlc_GetChipConfig_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_GetChipConfig_RetVal.SLEWRATE, 5u, ==); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetADCResult_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function returns the ADC results and quality flag on selected Mlc device /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetADCResult_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_GetADCResult_Param1 = 1u; CddMlc_sAdcResult_List[CddMlc_GetADCResult_Param1].ucADC1Value = 0xFE; CddMlc_sAdcResult_List[CddMlc_GetADCResult_Param1].ucADC2Value = 0xFE; CddMlc_sAdcResult_List[CddMlc_GetADCResult_Param1].eQlty = CDD_MLC_QLTY_VALID; //Step 3) Call FUT CddMlc_GetADCResult_RetVal = CddMlc_GetADCResult(CddMlc_GetADCResult_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_GetADCResult_RetVal.ucADC1Value, 0xFE, == ); AL_UNITTEST_CHECK(CddMlc_GetADCResult_RetVal.ucADC2Value, 0xFE, == ); AL_UNITTEST_CHECK(CddMlc_GetADCResult_RetVal.eQlty, CDD_MLC_QLTY_VALID, == ); } //----------------------------------------------------------------------------- /// \Test Case :Mt_CddMlc_CddMlc_GetLedsStatus_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function returns the status of LEDs on selected Mlc device /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetLedsStatus_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_GetLedsStatus_Param1 = 1u; CddMlc_LedStatus_List[CddMlc_GetLedsStatus_Param1].unLedFault = 0xFFFu; //Step 3) Call FUT CddMlc_GetLedsStatus_RetVal = CddMlc_GetLedsStatus(CddMlc_GetLedsStatus_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_GetLedsStatus_RetVal.unLedFault, 0xFFFu, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetComStatus_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that the function CddMlc_GetComStatus returns the communication status of all Mlc chips /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetComStatus_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlc_ComStatus.ulMlcStatus = 0u; CddMlc_ComStatus.ulPowerCycleOccurred = 0u; //Init UART Communication Errors Occurrence Counter CddMlc_ComStatus.ulUartErrorsOccurred = 0u; //Init Tx Overrun Counter CddMlc_ComStatus.ulTxCommandOverrun = 0u; //Init the Variant Chip Settings flag CddMlc_ComStatus.ulAckChipSetting = 0x7Fu; //Init the Variant Phase Shifts flag CddMlc_ComStatus.ulAckPhaseShifts = 0x7Fu; //Init the Variant LED Segments flag CddMlc_ComStatus.ulAckLedSegments = 0x7Fu; //Step 3) Call FUT CddMlc_GetComStatus_RetVal = CddMlc_GetComStatus(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_GetComStatus_RetVal.ulMlcStatus, 0u, == ); AL_UNITTEST_CHECK(CddMlc_GetComStatus_RetVal.ulPowerCycleOccurred, 0u, == ); AL_UNITTEST_CHECK(CddMlc_GetComStatus_RetVal.ulUartErrorsOccurred, 0u, == ); AL_UNITTEST_CHECK(CddMlc_GetComStatus_RetVal.ulTxCommandOverrun, 0u, == ); AL_UNITTEST_CHECK(CddMlc_GetComStatus_RetVal.ulAckChipSetting, 0x7Fu, == ); AL_UNITTEST_CHECK(CddMlc_GetComStatus_RetVal.ulAckPhaseShifts, 0x7Fu, == ); AL_UNITTEST_CHECK(CddMlc_GetComStatus_RetVal.ulAckLedSegments, 0x7Fu, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_StepToNextChip_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: /// Check if the function CddMlc_StepToNextChip jumps to the next Mlc chip for multiplexed commands /// /// - Test Design Technique: DT (Decision Table) /// The Decision Table asTestCaseData[] is used in this test case. This DT contains all possible values of all inputs /// which are taken into account by the algorithm of the FUT, as well as the expected values of all outputs which are /// set by the FUT. /// - DT-Info: /// - Inputs: /// actualChipNumber : known value of internal variable before calling FUT /// - Expected results /// returnedChipNumber : expected return value by the FUT /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_StepToNextChip_TestCase(void) { typedef struct tsTestCaseDataInput { uint8 actualChipNumber; }tsTestCaseDataInput; typedef struct tsTestCaseDataOutput { uint8 returnedChipNumber; }tsTestCaseDataOutput; typedef struct tsTestCaseData { tsTestCaseDataInput sInputData; tsTestCaseDataOutput sOutputData; }tsTestCaseData; tsTestCaseData asTestCaseData[] = { // Inputs || Outputs // actual ChipNumber || returned ChipNumber { { 0u } , { 1u } }, { { 1u } , { 2u } }, { { 2u } , { 3u } }, { { 3u } , { 4u } }, { { 4u } , { 5u } }, { { 5u } , { 6u } }, { { 6u } , { 0u } }, { { 7u } , { 0u } }, }; //Step 1: Set pre-conditions for (uint8 ucIdx = 0; ucIdx < sizeof(asTestCaseData) / sizeof(tsTestCaseData); ucIdx++) { //Step 2) Assign Input values CddMlc_ucChipNbr = asTestCaseData[ucIdx].sInputData.actualChipNumber; //Step 3) Call FUT CddMlc_StepToNextChip(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucChipNbr, asTestCaseData[ucIdx].sOutputData.returnedChipNumber, == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ScheduleCommands_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: /// Check if the function CddMlc_ScheduleCommands prepare/update the Mlc command messages and then, /// add them to UART queue buffer and store their reference status /// /// - Test Design Technique: DT (Decision Table) /// The Decision Table asTestCaseData[] is used in this test case. This DT contains all possible values of all inputs /// which are taken into account by the algorithm of the FUT, as well as the expected values of all outputs which are /// set by the FUT. /// - DT-Info: /// - Inputs: /// actualState : known value of internal variable before calling FUT /// - Expected results /// returnedState : expected return value by the FUT /// /// - Preconditions: //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ScheduleCommands_TestCase(void) { typedef struct tsTestCaseDataInput { tCddMlc_SystemMode actualState; }tsTestCaseDataInput; typedef struct tsTestCaseDataOutput { tCddMlc_SystemMode returnedState; }tsTestCaseDataOutput; typedef struct tsTestCaseData { tsTestCaseDataInput sInputData; tsTestCaseDataOutput sOutputData; }tsTestCaseData; tsTestCaseData asTestCaseData[] = { // Inputs || Outputs // actual state || returned state { { CddMlc_SystemMode_Powerup } , {CddMlc_SystemMode_Powerup } }, { { CddMlc_SystemMode_CfgComm } , {CddMlc_SystemMode_CfgChips } }, { { CddMlc_SystemMode_CfgChips } , {CddMlc_SystemMode_CfgPhases } }, { { CddMlc_SystemMode_CfgPhases } , {CddMlc_SystemMode_CfgLeds } }, { { CddMlc_SystemMode_CfgLeds } , {CddMlc_SystemMode_Normal } }, { { CddMlc_SystemMode_Normal } , {CddMlc_SystemMode_Normal } }, { { CddMlc_SystemMode_Inactive } , {CddMlc_SystemMode_Inactive } }, { { CddMlc_SystemMode_Length } , {CddMlc_SystemMode_Length } }, }; for (uint8 ucIdx = 0; ucIdx < sizeof(asTestCaseData) / sizeof(tsTestCaseData); ucIdx++) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlc_SystemMode = asTestCaseData[ucIdx].sInputData.actualState; //Step 3) Call FUT CddMlc_ScheduleCommands(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, asTestCaseData[ucIdx].sOutputData.returnedState, == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_SetTargetValues_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Checks that function sets the LED intensities for the current Mlc chip /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_SetTargetValues_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_SetTargetValues_Param1 = 1u; for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_LEDS; ucIdx++) { CddMlc_SetTargetValues_Param2[ucIdx] = unTargetWidths_List[ucIdx]; } //Step 3) Call FUT CddMlc_SetTargetValues(CddMlc_SetTargetValues_Param1, CddMlc_SetTargetValues_Param2); //Step 4) Check expected output values for (uint8 ucSegNbr = 0u; ucSegNbr < CDD_MLC_LEDS; ucSegNbr++) { AL_UNITTEST_CHECK(CddMlc_unTargetLedWidths_List[1][ucSegNbr], CddMlc_SetTargetValues_Param2[ucSegNbr], == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_Cycle_TestCase /// /// \Functional Safety: NA /// /// /// \Test Case Description /// - Test subject: Check that function Led Matrix Manager Cyclic Handler /// which calls CddMlc_Cycle() performs commands scheduling and /// returns the correct Mlc state after each processed command /// /// - Test Design Technique: DT (Decision Table) /// The Decision Table asTestCaseData[] is used in this test case. This DT contains all possible values of all inputs /// which are taken into account by the algorithm of the FUT, as well as the expected values of all outputs which are /// set by the FUT. /// - DT-Info: /// - Inputs: /// actualState : known value of internal variable before calling FUT /// - Expected results /// returnedState : expected return value by the FUT /// /// - Preconditions: //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_Cycle_TestCase(void) { typedef struct tsTestCaseDataInput { tCddMlc_SystemMode actualState; }tsTestCaseDataInput; typedef struct tsTestCaseDataOutput { tCddMlc_SystemMode returnedState; }tsTestCaseDataOutput; typedef struct tsTestCaseData { tsTestCaseDataInput sInputData; tsTestCaseDataOutput sOutputData; }tsTestCaseData; tsTestCaseData asTestCaseData[] = { // Inputs || Outputs // actual state || returned state { { CddMlc_SystemMode_Powerup } , {CddMlc_SystemMode_Powerup } }, { { CddMlc_SystemMode_CfgComm } , {CddMlc_SystemMode_CfgChips } }, { { CddMlc_SystemMode_CfgChips } , {CddMlc_SystemMode_CfgPhases } }, { { CddMlc_SystemMode_CfgPhases } , {CddMlc_SystemMode_CfgLeds } }, { { CddMlc_SystemMode_CfgLeds } , {CddMlc_SystemMode_Normal } }, { { CddMlc_SystemMode_Normal } , {CddMlc_SystemMode_Normal } }, { { CddMlc_SystemMode_Inactive } , {CddMlc_SystemMode_Inactive } }, { { CddMlc_SystemMode_Length } , {CddMlc_SystemMode_Length } }, }; for (uint8 ucIdx = 0; ucIdx < sizeof(asTestCaseData) / sizeof(tsTestCaseData); ucIdx++) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlc_SystemMode = asTestCaseData[ucIdx].sInputData.actualState; //Step 3) Call FUT CddMlc_Cycle(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, asTestCaseData[ucIdx].sOutputData.returnedState, == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase1 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case ACK Byte was received for Cfg. Communication command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_CfgComm /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_ICID] = 0x1F /// /// - Expected results /// CddMlc_ComStatus.ucMatrixIcID_List[1u] = 0x1F /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_ICID] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_CfgComm; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_ICID] = 0x1F; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ucMatrixIcID_List[1u], 0x1F, == ); AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_ICID], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase2 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case ACK Byte was received for Cfg. Chips command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_CfgChips /// CddMlc_ComStatus.ulAckChipSetting = 0u /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_CHIP] = 0x7F /// /// - Expected results /// CddMlc_ComStatus.ulAckChipSetting = 2u /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_CHIP] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_CfgChips; CddMlc_ComStatus.ulAckChipSetting = 0u; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_CHIP] = CDD_MLC_ACK_BYTE; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulAckChipSetting, 2u, == ); AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_CHIP], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase3 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case ACK Byte was received for Cfg. Phases /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_CfgPhases /// CddMlc_ComStatus.ulAckPhaseShifts = 0u /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_PHASE] = 0x7F /// /// - Expected results /// CddMlc_ComStatus.ulAckPhaseShifts = 2u /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_PHASE] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase3(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_CfgPhases; CddMlc_ComStatus.ulAckPhaseShifts = 0u; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_PHASE] = CDD_MLC_ACK_BYTE; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulAckPhaseShifts, 2u, == ); AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_PHASE], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase4 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case ACK Byte was received for Cfg. Leds command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_CfgLeds /// CddMlc_ComStatus.ulAckLedSegments = 0u /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_STRING] = 0x7F /// /// - Expected results /// CddMlc_ComStatus.ulAckLedSegments = 2u /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_STRING] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase4(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_CfgLeds; CddMlc_ComStatus.ulAckLedSegments = 0u; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_STRING] = CDD_MLC_ACK_BYTE; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulAckLedSegments, 2u, == ); AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_STRING], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase5 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case ACK Byte was received for PWMs update command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_Normal /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_WIDTH] = 0x7F /// /// - Expected results /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_WIDTH] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase5(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_Normal; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_WIDTH] = CDD_MLC_ACK_BYTE; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_WIDTH], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase6 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case no ACK Byte was received for Cfg. Chips command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_CfgChips /// CddMlc_ComStatus.ulAckChipSetting = 0u /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_CHIP] = 0x00 /// /// - Expected results /// CddMlc_ComStatus.ulAckChipSetting = 0u /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_CHIP] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase6(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_CfgChips; CddMlc_ComStatus.ulAckChipSetting = 0u; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_CHIP] = 0x00u; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulAckChipSetting, 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_CHIP], 0x0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase7 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case no ACK Byte was received for Cfg. Phases command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_CfgPhases /// CddMlc_ComStatus.ulAckPhaseShifts = 0u /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_PHASE] = 0x00u /// /// - Expected results /// CddMlc_ComStatus.ulAckPhaseShifts = 0u /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_PHASE] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase7(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_CfgPhases; CddMlc_ComStatus.ulAckPhaseShifts = 0u; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_PHASE] = 0x00u; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulAckPhaseShifts, 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_PHASE], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase8 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case no ACK Byte was received for Cfg. Leds command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_CfgLeds /// CddMlc_ComStatus.ulAckLedSegments = 0u /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_STRING] = 0x00u /// /// - Expected results /// CddMlc_ComStatus.ulAckLedSegments = 0u /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_STRING] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase8(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_CfgLeds; CddMlc_ComStatus.ulAckLedSegments = 0u; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_CFG_STRING] = 0x00u; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulAckLedSegments, 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_CFG_STRING], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase9 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that function decodes the responses of the individual chip commands /// in case no ACK Byte was received for PWMs update command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_ResponseHandler_Param1 = 1u /// CddMlc_LastSystemMode = CddMlc_SystemMode_Normal /// CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_WIDTH] = 0x00u /// /// - Expected results /// CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_WIDTH] = 0x00u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase9(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ResponseHandler_Param1 = 1u; CddMlc_LastSystemMode = CddMlc_SystemMode_Normal; CddMlc_ucResponse_List[CddMlc_ResponseHandler_Param1][CDD_MLC_N_TX_WIDTH] = 0x00u; //Step 3) Call FUT CddMlc_ResponseHandler(CddMlc_ResponseHandler_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucResponse_List[1u][CDD_MLC_N_TX_WIDTH], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_ResponseHandler_TestCase /// /// \Test Case Description /// - Test subject: Verifiy the responses of the individual chip commands /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_ResponseHandler_TestCase(void) { Mt_CddMlc_CddMlc_ResponseHandler_TestCase1(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase2(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase3(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase4(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase5(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase6(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase7(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase8(); Mt_CddMlc_CddMlc_ResponseHandler_TestCase9(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_InterpretResponses_TestCase1 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that The function sets the signal quality flags for a Read ADC command /// in case of an invalid command (Command status = NULL_PTR) /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// - Inputs: /// CddMlc_psCommmandStatus[CDD_MLC_CMD_IDX_READ_ADCS] = NULL_PTR /// CddMlc_ComStatus.ucTimeoutCounter_List[1u] = CDD_MLC_TIMEOUT_THD - 1 /// /// - Expected results /// CddMlc_sAdcResult_List[1u].eQlty = CDD_MLC_QLTY_SNA /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_InterpretResponses_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_psCommmandStatus[CDD_MLC_CMD_IDX_READ_ADCS] = NULL_PTR; CddMlc_ComStatus.ucTimeoutCounter_List[1u] = CDD_MLC_TIMEOUT_THD - 1; //Step 3) Call FUT CddMlc_InterpretResponses(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[1u].eQlty, CDD_MLC_QLTY_SNA, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_InterpretResponses_TestCase2 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that The function decodes the responses from previous commands cycle, /// saves the values of ADCs, FAULT registers etc and /// updates the global status depending of the commands status. /// and increments TxCommandOverrun if the message is pending /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_InterpretResponses_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boRxSuccess = 1u; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boEntryUsed = 1u; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boFramingError = 1u; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boBitError = 1u; CddMlc_psCommmandStatus[CDD_MLC_CMD_IDX_READ_FLTS] = &CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS]; CddMlc_ComStatus.ulTxCommandOverrun = 5u; //Step 3) Call FUT CddMlc_InterpretResponses(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_psCommmandStatus[CDD_MLC_CMD_IDX_READ_FLTS], NULL_PTR, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ulTxCommandOverrun, 6u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_InterpretResponses_TestCase3 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: Check that The function decodes the responses from previous commands cycle, /// saves the values of ADCs, FAULT registers etc and /// updates the global status depending of the commands status. /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_InterpretResponses_TestCase3(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boRxSuccess = 1u; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boEntryUsed = 0u; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boFramingError = 1u; CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS].boBitError = 1u; CddMlc_psCommmandStatus[CDD_MLC_CMD_IDX_READ_FLTS] = &CddMlc_CommandStatusTemp[CDD_MLC_CMD_IDX_READ_FLTS]; CddMlc_ComStatus.ulTxCommandOverrun = 0u; //Step 3) Call FUT CddMlc_InterpretResponses(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_psCommmandStatus[CDD_MLC_CMD_IDX_READ_FLTS], NULL_PTR, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ulTxCommandOverrun, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_InterpretResponses_TestCase /// /// \Test Case Description /// - Test subject: Decode the responses from previuos commands cycle /// and update the global status /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_InterpretResponses_TestCase(void) { Mt_CddMlc_CddMlc_InterpretResponses_TestCase1(); Mt_CddMlc_CddMlc_InterpretResponses_TestCase2(); Mt_CddMlc_CddMlc_InterpretResponses_TestCase3(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandSuccess_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function resets communication status faults /// for the current MLC chip /// /// - Preconditions: /// /// \input CddMlc_CommandSuccess_Param1 = 1u /// /// - Expectations: /// /// \output CddMlc_ComStatus.ucTimeoutCounter_List[1u] = 0x00u /// \output CddMlc_ComStatus.ulMlcStatus = 0u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandSuccess_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandSuccess_Param1 = 1u; //Step 3) Call FUT CddMlc_CommandSuccess(CddMlc_CommandSuccess_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ucTimeoutCounter_List[1u], 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ulMlcStatus, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandSuccess_TestCase2 /// /// \Test Case Description /// - Test subject: /// Test if function executes the read configuration command, /// saves the system chips configuration and sets the /// PowerCycle flag for the current MLC chip /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: CddMlc_ucResRdConfig_List initialized /// /// - Expected test results: /// - System Configuration Settings must be saved in CddMlc_ucChipSysConfig_List /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandSuccess_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandSuccess_Param1 = CDD_MLC_CMD_IDX_READ_CNFG; CddMlc_ComStatus.ulPowerCycleOccurred = 0u; CddMlc_ucChipNbr = 0u; for (uint8 ucIdx = 5u; ucIdx < CDD_MLC_N_RX_CONFIG; ucIdx++) { if (ucIdx >= 5u && ucIdx <= 13u) { CddMlc_ucResRdConfig_List[ucIdx] = ucIdx; } else if (ucIdx >= 21u && ucIdx <= 24u) { CddMlc_ucResRdConfig_List[ucIdx] = ucIdx + 1u; } else if (ucIdx == 37u) { CddMlc_ucResRdConfig_List[ucIdx] = 0x7F; } else if (ucIdx == 38u) { CddMlc_ucResRdConfig_List[ucIdx] = 0x67; } else { CddMlc_ucResRdConfig_List[ucIdx] = 0x00u; } } CddMlc_ucChipSysConfig_List[1u] = (tCddMlc_RegisterConfig) { 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u }; //Step 3) Call FUT CddMlc_CommandSuccess(CddMlc_CommandSuccess_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].SLEWRATE, 5u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].OVLMT, 6u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].PARLED, 7u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].DEFWIDTH02_01, 8u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].DEFWIDTH04_03, 9u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].DEFWIDTH06_05, 10u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].DEFWIDTH08_07, 11u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].DEFWIDTH10_09, 12u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].DEFWIDTH12_11, 13u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].SYSCFG, 22u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].CMWTAP, 23u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].PWMTICK, 24u, == ); AL_UNITTEST_CHECK(CddMlc_ucChipSysConfig_List[0u].ADCID, 25u, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ulPowerCycleOccurred, 1u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandSuccess_TestCase3 /// /// \Test Case Description /// - Test subject: /// Test if function executes the read configuration command, /// saves the system chips configuration and resets the /// PowerCycle flag for the current MLC chip /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: CddMlc_ucResRdConfig_List initialized /// /// - Expected test results: /// - System Configuration Settings must be saved in CddMlc_ucChipSysConfig_List /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandSuccess_TestCase3(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandSuccess_Param1 = CDD_MLC_CMD_IDX_READ_CNFG; CddMlc_ComStatus.ulPowerCycleOccurred = 0u; for (uint8 ucIdx = 5u; ucIdx < CDD_MLC_N_RX_CONFIG; ucIdx++) { if (ucIdx >= 5u && ucIdx <= 13u) { CddMlc_ucResRdConfig_List[ucIdx] = ucIdx + 1u; } else if (ucIdx >= 21u && ucIdx <= 24u) { CddMlc_ucResRdConfig_List[ucIdx] = ucIdx; } else { CddMlc_ucResRdConfig_List[ucIdx] = 0x00u; } } CddMlc_ucChipSysConfig_List[0u] = (tCddMlc_RegisterConfig) { 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u }; //Step 3) Call FUT CddMlc_CommandSuccess(CddMlc_CommandSuccess_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulPowerCycleOccurred, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandSuccess_TestCase4 /// /// \Test Case Description /// - Test subject: /// Test if function executes the read ADC values, saving the curent values /// and validating the ADC result flag /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: CddMlc_ucResRdADC_List initialized /// /// - Expected test results: /// - ADC values must be saved in CddMlc_sAdcResult_List /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandSuccess_TestCase4(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandSuccess_Param1 = CDD_MLC_CMD_IDX_READ_ADCS; CddMlc_sAdcResult_List[0u] = (tCddMlc_AdcResult) { 0x55u, 0x00u, { 0x00u } }; CddMlc_ucResRdADC_List[CDD_MLC_N_TX_ADC + 0u] = 242u; CddMlc_ucResRdADC_List[CDD_MLC_N_TX_ADC + 1u] = 142u; //Step 3) Call FUT CddMlc_CommandSuccess(CddMlc_CommandSuccess_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[0u].ucADC1Value, 242u, == ); AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[0u].ucADC2Value, 142u, == ); AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[0u].eQlty, CDD_MLC_QLTY_VALID, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandSuccess_TestCase5 /// /// \Test Case Description /// - Test subject: /// Test if function executes the read LED Faults command, saving the received /// Led fault status and Crc error counter /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: CddMlc_ucResRdFault_List initialized /// /// - Expected test results: /// - Led faults must be saved in CddMlc_LedStatus_List /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandSuccess_TestCase5(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandSuccess_Param1 = CDD_MLC_CMD_IDX_READ_FLTS; CddMlc_ComStatus.ucCrcFltOccurrence_List[0u] = 0x00u; CddMlc_LedStatus_List[0u] = (tCddMlc_LedStatus) { 0x00u, 0x00u }; CddMlc_ucResRdFault_List[CDD_MLC_N_TX_FAULT + 0u] = 0xFEu; CddMlc_ucResRdFault_List[CDD_MLC_N_TX_FAULT + 1u] = 0x00u; CddMlc_ucResRdFault_List[CDD_MLC_N_TX_FAULT + 2u] = 0x02u; //Step 3) Call FUT CddMlc_CommandSuccess(CddMlc_CommandSuccess_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_LedStatus_List[0u].unLedFault, 0x00FEu, == ); AL_UNITTEST_CHECK(CddMlc_LedStatus_List[0u].unLedFault, 0x00FEu, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ucCrcFltOccurrence_List[0u], 0x02u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandSuccess_TestCase5 /// /// \Test Case Description /// - Test subject: /// Test if function returns when commands out of interest are given to be /// evaluated /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: none /// /// - Expected test results: /// - return from function /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandSuccess_TestCase6(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandSuccess_Param1 = CDD_MLC_CMD_IDX_READ_FLTS + 1u; CddMlc_ComStatus.ucCrcFltOccurrence_List[0u] = 0u; CddMlc_ComStatus.ulMlcStatus = 0u; //Step 3) Call FUT CddMlc_CommandSuccess(CddMlc_CommandSuccess_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ucCrcFltOccurrence_List[0u], 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ComStatus.ulMlcStatus, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandSuccess_TestCase /// /// \Test Case Description /// - Test subject: Decode the responses from previuos commands cycle /// and save the results /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandSuccess_TestCase(void) { Mt_CddMlc_CddMlc_CommandSuccess_TestCase1(); Mt_CddMlc_CddMlc_CommandSuccess_TestCase2(); Mt_CddMlc_CddMlc_CommandSuccess_TestCase3(); Mt_CddMlc_CddMlc_CommandSuccess_TestCase4(); Mt_CddMlc_CddMlc_CommandSuccess_TestCase5(); Mt_CddMlc_CddMlc_CommandSuccess_TestCase6(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandFailed_TestCase1 /// /// \Test Case Description /// - Test subject: /// Test if function increments timeout counter in case timeout was not reached /// evaluated /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: none /// /// - Expected test results: /// - CddMlc_ComStatus.ucTimeoutCounter_List[CddMlc_CommandFailed_Param1] = CDD_MLC_TIMEOUT_THD /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandFailed_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandFailed_Param1 = CDD_MLC_CHIPS - 1u; CddMlc_ComStatus.ucTimeoutCounter_List[CddMlc_CommandFailed_Param1] = CDD_MLC_TIMEOUT_THD - 1u; //Step 3) Call FUT CddMlc_CommandFailed(CddMlc_CommandFailed_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ucTimeoutCounter_List[CddMlc_CommandFailed_Param1], CDD_MLC_TIMEOUT_THD/*CddMlc_ComStatus.ucTimeoutCounter_List[CddMlc_CommandFailed_Param1]++*/, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandFailed_TestCase1 /// /// \Test Case Description /// - Test subject: /// Test if function adds timeout flag for current MLC in case timeout was reached /// evaluated /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: none /// /// - Expected test results: /// - CddMlc_ComStatus.ulMlcStatus = 64u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandFailed_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandFailed_Param1 = CDD_MLC_CHIPS - 1; CddMlc_ComStatus.ucTimeoutCounter_List[CddMlc_CommandFailed_Param1] = CDD_MLC_TIMEOUT_THD; CddMlc_ComStatus.ulMlcStatus = 0u; //Step 3) Call FUT CddMlc_CommandFailed(CddMlc_CommandFailed_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ComStatus.ulMlcStatus, 0b01000000 /*CddMlc_ComStatus.ulMlcStatus | ((uint32)1u << CddMlc_CommandFailed_Param1)*/, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandFailed_TestCase3 /// /// \Test Case Description /// - Test subject: /// Test if function sets ADC flag to SNA for current MLC in case timeout was not reached /// evaluated /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: none /// /// - Expected test results: /// - CddMlc_sAdcResult_List[0u].eQlty = CDD_MLC_QLTY_SNA /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandFailed_TestCase3(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandFailed_Param1 = CDD_MLC_CMD_IDX_READ_ADCS; CddMlc_ComStatus.ucTimeoutCounter_List[0u] = CDD_MLC_TIMEOUT_THD - 1u; CddMlc_sAdcResult_List[0u].eQlty = CDD_MLC_QLTY_INVALID; //Step 3) Call FUT CddMlc_CommandFailed(CddMlc_CommandFailed_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[0u].eQlty, CDD_MLC_QLTY_SNA, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandFailed_TestCase4 /// /// \Test Case Description /// - Test subject: /// Test if function sets ADC flag to INVALID for current MLC in case timeout was reached /// evaluated /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: none /// /// - Expected test results: /// - CddMlc_sAdcResult_List[0u].eQlty = CDD_MLC_QLTY_INVALID /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandFailed_TestCase4(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandFailed_Param1 = CDD_MLC_CMD_IDX_READ_ADCS; CddMlc_ComStatus.ucTimeoutCounter_List[0u] = CDD_MLC_TIMEOUT_THD; CddMlc_sAdcResult_List[0u].eQlty = CDD_MLC_QLTY_VALID; //Step 3) Call FUT CddMlc_CommandFailed(CddMlc_CommandFailed_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_sAdcResult_List[0u].eQlty, CDD_MLC_QLTY_INVALID, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_CommandFailed_TestCase5 /// /// \Test Case Description /// - Test subject: /// Test if function keeps the previous values for LED status in case /// the evaluated command is read faults or does nothing when other /// commands are evaluated /// /// - Test Design Technique: DT (Decision Table) /// /// - Preconditions: none /// /// - Expected test results: /// - CddMlc_LedStatus_List[1u].unLedFault = 0xFE /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandFailed_TestCase5(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_CommandFailed_Param1 = CDD_MLC_CMD_IDX_READ_FLTS; CddMlc_LedStatus_List[1u].unLedFault = 0xFE; //Step 3) Call FUT CddMlc_CommandFailed(CddMlc_CommandFailed_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_LedStatus_List[1u].unLedFault, 0xFE, == ); //Step 2) Assign Input values CddMlc_CommandFailed_Param1 = CDD_MLC_CMD_IDX_READ_FLTS + 1u; //no other valid commands, save current values //Step 3) Call FUT CddMlc_CommandFailed(CddMlc_CommandFailed_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_LedStatus_List[1u].unLedFault, 0xFE, == ); } //----------------------------------------------------------------------------- /// \Test Case : /// /// \Test Case Description /// - Test subject: Decode the previous commands and update the MLC /// chips communication status /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_CommandFailed_TestCase(void) { Mt_CddMlc_CddMlc_CommandFailed_TestCase1(); Mt_CddMlc_CddMlc_CommandFailed_TestCase2(); Mt_CddMlc_CddMlc_CommandFailed_TestCase3(); Mt_CddMlc_CddMlc_CommandFailed_TestCase4(); Mt_CddMlc_CddMlc_CommandFailed_TestCase5(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_MuxCommands_TestCase1 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: The function interrogates the LED status registers on a broadcast command /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_MuxCommands_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcTI_boDeviceResponse[0] = TRUE; //Step 3) Call FUT CddMlc_MuxCommands(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastFault_List[0u], CDD_MLC_WRITE_03_BYTES, == ); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastFault_List[1u], 0xBFu, == ); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastFault_List[2u], 0xB0u, == ); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastFault_List[3u], 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastFault_List[4u], 0x00u, == ); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastFault_List[5u], 0x00u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_MuxCommands_TestCase2 /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: The function interrogates the LED status registers for the current MLC chip /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_MuxCommands_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ucClearFaults = 0u; for (uint8 ucIdx = 0; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { CddMlcTI_boDeviceResponse[ucIdx] = TRUE; } //Step 3) Call FUT CddMlc_MuxCommands(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCmdRdFault_List[0], CDD_MLC_READ_03_BYTES, == ); AL_UNITTEST_CHECK(CddMlc_ucCmdRdFault_List[2], 0xB0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_MuxCommands_TestCase /// /// \Test Case Description /// - Test subject: Verify the multiplexed commands for the current chip /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_MuxCommands_TestCase(void) { Mt_CddMlc_CddMlc_MuxCommands_TestCase1(); Mt_CddMlc_CddMlc_MuxCommands_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetTargetBufAddress_TestCase /// /// \Functional Safety: NA /// /// \Test Case Description /// - Test subject: /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetTargetBufAddress_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_GetTargetBufAddress_RetVal = 0u; CddMlc_unTargetLedWidths_List[0u][0u] = 0x33u; //Step 3) Call FUT CddMlc_GetTargetBufAddress_RetVal = CddMlc_GetTargetBufAddress(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_GetTargetBufAddress_RetVal, (uint16*)(&CddMlc_unTargetLedWidths_List[0u][0u]), == ); AL_UNITTEST_CHECK(*CddMlc_GetTargetBufAddress_RetVal, 0x33u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function stores the address for each MLC device /// read from coding data if the device is not connected /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CDD_MLC_PHY_CHIP_ID[ucIdx] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED /// \input CddMlc_ucDevIdTableIdx_List[ucIdx] = 0u /// \input CddMlc_ucDevIdTable_List[ucIdx] = 0u /// /// - Expectations: /// /// \output CddMlc_ucDevIdTableIdx_List[ucIdx] = 0u /// \output CddMlc_ucDevIdTable_List[ucIdx] = 0u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { CDD_MLC_PHY_CHIP_ID[ucIdx] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED; CddMlc_ucDevIdTableIdx_List[ucIdx] = 0u; //global variable, needs to be reinitialized to be independent on other test cases CddMlc_ucDevIdTable_List[ucIdx] = 0u; } //Step 3) Call FUT CddMlc_GetMlcPhysicalAddress(); //Step 4) Check expected output values for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[ucIdx], 0u, == ); //global variable, needs to be reinitialized to be independent on other test cases AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[ucIdx], 0u, == ); } } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function stores the address for each MLC device /// read from coding data /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CDD_MLC_PHY_CHIP_ID[0u] = 0 /// \input CDD_MLC_PHY_CHIP_ID[1u] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED /// \input CDD_MLC_PHY_CHIP_ID[2u] = 2 /// \input CDD_MLC_PHY_CHIP_ID[3u] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED /// \input CDD_MLC_PHY_CHIP_ID[4u] = 4 /// \input CDD_MLC_PHY_CHIP_ID[5u] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED /// \input CDD_MLC_PHY_CHIP_ID[6u] = 6 /// \input CddMlc_ucDevIdTableIdx_List[ucIdx] = 0u /// \input CddMlc_ucDevIdTable_List[ucIdx] = 0u /// /// - Expectations: /// /// \output CddMlc_ucDevIdTableIdx_List[0u] = 0u /// \output CddMlc_ucDevIdTable_List[0u] = CDD_MLC_DEV_ID00 /// \output CddMlc_ucDevIdTableIdx_List[1u] = 2u /// \output CddMlc_ucDevIdTable_List[1u] = CDD_MLC_DEV_ID02 /// \output CddMlc_ucDevIdTableIdx_List[2u] = 4u /// \output CddMlc_ucDevIdTable_List[2u] = CDD_MLC_DEV_ID04 /// \output CddMlc_ucDevIdTableIdx_List[3u] = 6u /// \output CddMlc_ucDevIdTable_List[3u] = CDD_MLC_DEV_ID06 /// \output CddMlc_ucDevIdTableIdx_List[4u] = 0u /// \output CddMlc_ucDevIdTable_List[4u] = 0u /// \output CddMlc_ucDevIdTableIdx_List[5u] = 0u /// \output CddMlc_ucDevIdTable_List[5u] = 0u /// \output CddMlc_ucDevIdTableIdx_List[6u] = 0u /// \output CddMlc_ucDevIdTable_List[6u] = 0u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CDD_MLC_PHY_CHIP_ID[0u] = 0; CDD_MLC_PHY_CHIP_ID[1u] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED; CDD_MLC_PHY_CHIP_ID[2u] = 2; CDD_MLC_PHY_CHIP_ID[3u] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED; CDD_MLC_PHY_CHIP_ID[4u] = 4; CDD_MLC_PHY_CHIP_ID[5u] = (uint8)MLC_DEV_ADDR_NOT_CONNECTED; CDD_MLC_PHY_CHIP_ID[6u] = 6; for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { CddMlc_ucDevIdTableIdx_List[ucIdx] = 0u; //global variable, needs to be reinitialized to be independent on other test cases CddMlc_ucDevIdTable_List[ucIdx] = 0u; } //Step 3) Call FUT CddMlc_GetMlcPhysicalAddress(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[0u], 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[0u], CDD_MLC_DEV_ID00, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[1u], 2u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[1u], CDD_MLC_DEV_ID02, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[2u], 4u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[2u], CDD_MLC_DEV_ID04, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[3u], 6u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[3u], CDD_MLC_DEV_ID06, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[4u], 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[4u], 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[5u], 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[5u], 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTableIdx_List[6u], 0u, == ); AL_UNITTEST_CHECK(CddMlc_ucDevIdTable_List[6u], 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase /// /// \Test Case Description /// - Test subject: Verify if the physical address is decoded /// considering the input value from coding /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase(void) { Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase1(); Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_BroadcastComm_TestCase /// /// \Test Case Description /// - Test subject: Test if function selects the Broadcast ADCID and calculates /// the CRC over data /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCmdBroadcastCfgComm_List[ucIdx] = 0u (ucIdx < 14) /// \input CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u (ucDevNr <7; ucIdx <5) /// \input CddMlc_ucDevIdTable_List[ucIdx] = { CDD_MLC_DEV_ID00 , CDD_MLC_DEV_ID01, CDD_MLC_DEV_ID02, CDD_MLC_DEV_ID03, CDD_MLC_DEV_ID04, CDD_MLC_DEV_ID05, CDD_MLC_DEV_ID06, CDD_MLC_DEV_ID07 } /// /// - Expectations: /// /// \output CddMlc_ucCmdBroadcastCfgComm_List[0u] = 0x87 /// \output CddMlc_ucCmdBroadcastCfgComm_List[1u] = 0xBF /// \output CddMlc_ucCmdBroadcastCfgComm_List[2u] = 0x83 /// \output CddMlc_ucCmdBroadcastCfgComm_List[3u] = 0x00 /// \output CddMlc_ucCmdBroadcastCfgComm_List[4u] = 0x78 /// \output CddMlc_ucCmdBroadcastCfgComm_List[5u] = 0x60 /// \output CddMlc_ucCmdBroadcastCfgComm_List[6u] = 0x1E /// \output CddMlc_ucCmdBroadcastCfgComm_List[7u] = 0xBF /// \output CddMlc_ucCmdBroadcastCfgComm_List[8u] = 0x80 /// \output CddMlc_ucCmdBroadcastCfgComm_List[9u] = 0x21 /// \output CddMlc_ucCmdBroadcastCfgComm_List[10u] = 0x5 /// \output CddMlc_ucCmdBroadcastCfgComm_List[11u] = 0x3E /// \output CddMlc_ucCmdBroadcastCfgComm_List[12u] = 0xED /// \output CddMlc_ucCmdBroadcastCfgComm_List[13u] = 0x2F /// \output CddMlc_ucCommand_List[1u][0u] = 0x4B /// \output CddMlc_ucCommand_List[1u][1u] = 0x61 /// \output CddMlc_ucCommand_List[1u][2u] = 0xFF /// \output CddMlc_ucCommand_List[1u][3u] = 0x19 /// \output CddMlc_ucCommand_List[1u][4u] = 0xC6 /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_BroadcastComm_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_N_TX_CFG_COM; ucIdx++) { //reset command broadcast CddMlc_ucCmdBroadcastCfgComm_List[ucIdx] = 0u; } for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_N_TX_ICID; ucIdx++) //reset command broadcast CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u; } for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { //assign addresses CddMlc_ucDevIdTable_List[ucIdx] = CddMlc_aucAddress[ucIdx]; } //Step 3) Call FUT CddMlc_BroadcastComm(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[0u], 0x87, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[1u], 0xBF, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[2u], 0x83, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[3u], 0x00, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[4u], 0x78, ==);//CRC AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[5u], 0x60, ==);//CRC AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[6u], 0x1E, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[7u], 0xBF, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[8u], 0x80, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[9u], 0x21, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[10u], 0x5, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[11u], 0x3E, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[12u], 0xED, ==); AL_UNITTEST_CHECK(CddMlc_ucCmdBroadcastCfgComm_List[13u], 0x2F, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][0u], 0x4B, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][1u], CDD_MLC_DEV_ID01, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][2u], 0xFF, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][3u], 0x19, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][4u], 0xC6, ==); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_WriteCfgChips_TestCase /// /// \Test Case Description /// - Test subject: Test if function computes the Chip Configuration Commands /// for a given MLC chip /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u (ucDevNr <7; ucIdx <21) /// \input CddMlc_ucDevIdTable_List[ucIdx] = { CDD_MLC_DEV_ID00 , CDD_MLC_DEV_ID01, CDD_MLC_DEV_ID02, CDD_MLC_DEV_ID03, CDD_MLC_DEV_ID04, CDD_MLC_DEV_ID05, CDD_MLC_DEV_ID06, CDD_MLC_DEV_ID07 } /// /// - Expectations: /// /// \output CddMlc_ucCommand_List[4u][0u] = 0x1E /// \output CddMlc_ucCommand_List[4u][1u] = 0x64 /// \output CddMlc_ucCommand_List[4u][2u] = 0x80 /// \output CddMlc_ucCommand_List[4u][3u] = 0x61 /// \output CddMlc_ucCommand_List[4u][4u] = 0x05 /// \output CddMlc_ucCommand_List[4u][5u] = 0x3E /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_WriteCfgChips_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_N_TX_WIDTH; ucIdx++) //reset command buffer CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u; } for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { //assign addresses CddMlc_ucDevIdTable_List[ucIdx] = CddMlc_aucAddress[ucIdx]; } //Step 3) Call FUT CddMlc_WriteCfgChips(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCommand_List[2u][0u], 0x1E, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[2u][1u], CDD_MLC_DEV_ID02, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[2u][2u], 0x80, ==); #if (CDD_MLC_I2C_ENABLED == CDD_MLC_FEATURE_ON) AL_UNITTEST_CHECK(CddMlc_ucCommand_List[2u][3u], 0x61, == ); #else AL_UNITTEST_CHECK(CddMlc_ucCommand_List[2u][3u], 0x21, == ); #endif AL_UNITTEST_CHECK(CddMlc_ucCommand_List[2u][4u], 0x05, ==); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[2u][5u], 0x3E, ==); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_WriteCfgPhases_TestCase /// /// \Test Case Description /// - Test subject: Test if function computes the Phase Shifts Configuration /// Commands for a given MLC chip /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u (ucDevNr <7; ucIdx <21) /// \input CddMlc_ucDevIdTable_List[ucIdx] = { CDD_MLC_DEV_ID00 , CDD_MLC_DEV_ID01, CDD_MLC_DEV_ID02, CDD_MLC_DEV_ID03, CDD_MLC_DEV_ID04, CDD_MLC_DEV_ID05, CDD_MLC_DEV_ID06, CDD_MLC_DEV_ID07 } /// /// - Expectations: /// /// \output CddMlc_ucCommand_List[1u][0u] = 0x33 /// \output CddMlc_ucCommand_List[1u][1u] = 0x61 /// \output CddMlc_ucCommand_List[1u][2u] = 0x00 /// \output CddMlc_ucCommand_List[1u][3u] = 0x00 /// \output CddMlc_ucCommand_List[1u][4u] = 0x55 /// \output CddMlc_ucCommand_List[1u][5u] = 0xAA /// \output CddMlc_ucCommand_List[1u][6u] = 0x00 /// \output CddMlc_ucCommand_List[1u][7u] = 0xFF /// \output CddMlc_ucCommand_List[1u][8u] = 0x55 /// \output CddMlc_ucCommand_List[1u][9u] = 0xAA /// \output CddMlc_ucCommand_List[1u][10u] = 0x14 /// \output CddMlc_ucCommand_List[1u][11u] = 0xFF /// \output CddMlc_ucCommand_List[1u][12u] = 0x54 /// \output CddMlc_ucCommand_List[1u][13u] = 0xAA /// \output CddMlc_ucCommand_List[1u][14u] = 0x29 /// \output CddMlc_ucCommand_List[1u][15u] = 0xFF /// \output CddMlc_ucCommand_List[1u][16u] = 0x54 /// \output CddMlc_ucCommand_List[1u][17u] = 0xA9 /// \output CddMlc_ucCommand_List[1u][18u] = 0x3E /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_WriteCfgPhases_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_N_TX_WIDTH; ucIdx++) //reset command buffer CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u; } for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { //assign addresses CddMlc_ucDevIdTable_List[ucIdx] = CddMlc_aucAddress[ucIdx]; } //Step 3) Call FUT CddMlc_WriteCfgPhases(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][0u], 0x33, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][1u], CDD_MLC_DEV_ID01, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][2u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][3u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][4u], 0x55, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][5u], 0xAA, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][6u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][7u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][8u], 0x55, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][9u], 0xAA, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][10u], 0x14, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][11u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][12u], 0x54, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][13u], 0xAA, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][14u], 0x29, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][15u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][16u], 0x54, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][17u], 0xA9, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][18u], 0x3E, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_WriteCfgLeds_TestCase /// /// \Test Case Description /// - Test subject: Test if function computes the LED Strings Configuration /// Commands for a given MLC chip /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u (ucDevNr <7; ucIdx <21) /// \input CddMlc_ucDevIdTable_List[ucIdx] = { CDD_MLC_DEV_ID00 , CDD_MLC_DEV_ID01, CDD_MLC_DEV_ID02, CDD_MLC_DEV_ID03, CDD_MLC_DEV_ID04, CDD_MLC_DEV_ID05, CDD_MLC_DEV_ID06, CDD_MLC_DEV_ID07 } /// /// - Expectations: /// /// \output CddMlc_ucCommand_List[1u][0u] = 0x2D /// \output CddMlc_ucCommand_List[1u][1u] = 0x61 /// \output CddMlc_ucCommand_List[1u][2u] = 0x70 /// \output CddMlc_ucCommand_List[1u][3u] = 0xFF /// \output CddMlc_ucCommand_List[1u][4u] = 0xAA /// \output CddMlc_ucCommand_List[1u][5u] = 0x00 /// \output CddMlc_ucCommand_List[1u][6u] = 0x00 /// \output CddMlc_ucCommand_List[1u][7u] = 0x00 /// \output CddMlc_ucCommand_List[1u][8u] = 0x00 /// \output CddMlc_ucCommand_List[1u][9u] = 0x00 /// \output CddMlc_ucCommand_List[1u][10u] = 0x00 /// \output CddMlc_ucCommand_List[1u][11u] = 0x00 /// \output CddMlc_ucCommand_List[1u][12u] = 0x00 /// \output CddMlc_ucCommand_List[1u][13u] = 0x00 /// \output CddMlc_ucCommand_List[1u][14u] = 0x00 /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_WriteCfgLeds_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_N_TX_WIDTH; ucIdx++) //reset command buffer CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u; } for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { //assign addresses CddMlc_ucDevIdTable_List[ucIdx] = CddMlc_aucAddress[ucIdx]; } //Step 3) Call FUT CddMlc_WriteCfgLeds(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][0u], 0x2D, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][1u], CDD_MLC_DEV_ID01, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][2u], 0x70, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][3u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][4u], 0xAA, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][5u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][6u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][7u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][8u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][9u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][10u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][11u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][12u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][13u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][14u], 0x00, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_WritePWMs_TestCase /// /// \Test Case Description /// - Test subject: Test if function computes the width (PWMs) write /// Commands for a given MLC chip /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0u (ucDevNr <7; ucIdx <21) /// \input CddMlc_ucDevIdTable_List[ucIdx] = { CDD_MLC_DEV_ID00 , CDD_MLC_DEV_ID01, CDD_MLC_DEV_ID02, CDD_MLC_DEV_ID03, CDD_MLC_DEV_ID04, CDD_MLC_DEV_ID05, CDD_MLC_DEV_ID06, CDD_MLC_DEV_ID07 } /// /// - Expectations: /// /// \output CddMlc_ucCommand_List[1u][0u] = 0x33 /// \output CddMlc_ucCommand_List[1u][1u] = 0x61 /// \output CddMlc_ucCommand_List[1u][2u] = 0x10 /// \output CddMlc_ucCommand_List[1u][3u] = 0xFF /// \output CddMlc_ucCommand_List[1u][4u] = 0xFF /// \output CddMlc_ucCommand_List[1u][5u] = 0xFF /// \output CddMlc_ucCommand_List[1u][6u] = 0x00 /// \output CddMlc_ucCommand_List[1u][7u] = 0xFF /// \output CddMlc_ucCommand_List[1u][8u] = 0xFF /// \output CddMlc_ucCommand_List[1u][9u] = 0xFF /// \output CddMlc_ucCommand_List[1u][10u] = 0x00 /// \output CddMlc_ucCommand_List[1u][11u] = 0xFF /// \output CddMlc_ucCommand_List[1u][12u] = 0xFF /// \output CddMlc_ucCommand_List[1u][13u] = 0xFF /// \output CddMlc_ucCommand_List[1u][14u] = 0x00 /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_WritePWMs_TestCase(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_N_TX_WIDTH; ucIdx++) //reset command buffer CddMlc_ucCommand_List[ucDevNr][ucIdx] = 0x0u; } for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { //assign addresses CddMlc_ucDevIdTable_List[ucIdx] = CddMlc_aucAddress[ucIdx]; } for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { for (uint8 ucIdx = 0u; ucIdx < CDD_MLC_LEDS; ucIdx++) { CddMlc_unTargetLedWidths_List[ucDevNr][ucIdx] = 0xFFu; } } //Step 3) Call FUT CddMlc_WritePWMs(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][0u], 0x33, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][1u], CDD_MLC_DEV_ID01, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][2u], 0x10, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][3u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][4u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][5u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][6u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][7u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][8u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][9u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][10u], 0x00, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][11u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][12u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][13u], 0xFF, == ); AL_UNITTEST_CHECK(CddMlc_ucCommand_List[1u][14u], 0x00, == ); } //----------------------------------------------------------------------------- // CddMlcUart.c //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_Init_TestCase /// /// \Test Case Description /// - Test subject: Test the initialization function for UART on NXPS32K146. /// /// - Preconditions: /// \input PERI->unDIV_8_CTL[PCLK_SCB3_DIV_8].stcField.u8INT8_DIV = 0u /// \input PERI->unDIV_CMD.stcField.u8DIV_SEL = 0u /// \input PERI->unDIV_CMD.stcField.u1ENABLE = 0u /// \input SCB_UART->unUART_RX_CTRL.stcField.u3STOP_BITS = 0u /// \input SCB_UART->unRX_CTRL.stcField.u5DATA_WIDTH = 0u /// \input SCB_UART->unUART_TX_CTRL.stcField.u3STOP_BITS = 0u /// \input SCB_UART->unTX_CTRL.stcField.u5DATA_WIDTH = 0u /// \input SCB_UART->unCTRL.stcField.u1ENABLED = 0u /// /// - Expectations: /// /// \output PERI->unDIV_8_CTL[PCLK_SCB3_DIV_8].stcField.u8INT8_DIV = 19u /// \output PERI->unDIV_CMD.stcField.u8DIV_SEL = PCLK_SCB3_DIV_8 /// \output PERI->unDIV_CMD.stcField.u1ENABLE = 1u /// \output SCB_UART->unUART_RX_CTRL.stcField.u3STOP_BITS = 1u /// \output SCB_UART->unRX_CTRL.stcField.u5DATA_WIDTH = 7u /// \output SCB_UART->unUART_TX_CTRL.stcField.u3STOP_BITS = 7u /// \output SCB_UART->unTX_CTRL.stcField.u5DATA_WIDTH = 7u /// \output SCB_UART->unCTRL.stcField.u1ENABLED = 1u //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_Init_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values PERI->unDIV_8_CTL[PCLK_SCB3_DIV_8].stcField.u8INT8_DIV = 0u; //80MHz /(1+19) = 4MHz for SCB Block PERI->unDIV_CMD.stcField.u8DIV_SEL = 0u; PERI->unDIV_CMD.stcField.u1ENABLE = 0u; SCB_UART->unUART_RX_CTRL.stcField.u3STOP_BITS = 0u; SCB_UART->unRX_CTRL.stcField.u5DATA_WIDTH = 0u; SCB_UART->unUART_TX_CTRL.stcField.u3STOP_BITS = 0u; SCB_UART->unTX_CTRL.stcField.u5DATA_WIDTH = 0u; SCB_UART->unCTRL.stcField.u1ENABLED = 0u; //Step 3) Call the FUT CddMlcUart_Init(); //Step 4) Check that the value of the output variables set/changed by the FUT matchs the corresponding expected output value AL_UNITTEST_CHECK(PERI->unDIV_8_CTL[PCLK_SCB3_DIV_8].stcField.u8INT8_DIV, 19u, ==); AL_UNITTEST_CHECK(PERI->unDIV_CMD.stcField.u8DIV_SEL, PCLK_SCB3_DIV_8 , ==); AL_UNITTEST_CHECK(PERI->unDIV_CMD.stcField.u1ENABLE, 1u , ==); AL_UNITTEST_CHECK(SCB_UART->unUART_RX_CTRL.stcField.u3STOP_BITS, 1u , ==); AL_UNITTEST_CHECK(SCB_UART->unRX_CTRL.stcField.u5DATA_WIDTH, 7u , ==); AL_UNITTEST_CHECK(SCB_UART->unUART_TX_CTRL.stcField.u3STOP_BITS, 7u , ==); AL_UNITTEST_CHECK(SCB_UART->unTX_CTRL.stcField.u5DATA_WIDTH, 7u , ==); AL_UNITTEST_CHECK(SCB_UART->unCTRL.stcField.u1ENABLED, 1u , ==); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_StartSend_TestCase /// /// \Test Case Description /// - Test subject: This function tests if the DMA parameters for Tx and Rx /// are set when a message needs to bge transferred /// /// - Preconditions: /// \input CddMlcUart_unSendReceive_Iterator = 0u /// \input CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].ucRxSize = 8u /// \input SCB_UART->unRX_FIFO_CTRL.stcField.u8TRIGGER_LEVEL = 0u /// /// - Expectations: /// /// \output SCB_UART->unRX_FIFO_CTRL.stcField.u8TRIGGER_LEVEL = 7u //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_StartSend_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlcUart_unSendReceive_Iterator = 0u; SCB_UART->unRX_FIFO_CTRL.stcField.u8TRIGGER_LEVEL = 0u; CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].ucRxSize = 8u; //Step 3) Call FUT CddMlcUart_StartSend(); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unRX_FIFO_CTRL.stcField.u8TRIGGER_LEVEL, 7u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase1 /// /// \Test Case Description /// - Test subject: Test if the callback function skips processing of a sent message /// and sets the DMA flags as ready /// /// - Preconditions: /// /// \input CddMlcUart_unSendReceive_Iterator = 0U /// \input CddMlcUart_boRxSuccess = TRUE /// \input CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].sStatus.boEntryUsed = FALSE /// \input CddMlcUart_Buffer[1u].sStatus.boEntryUsed = FALSE /// \input CddMlcUart_boIsUartReady = FALSE /// \input SCB_UART->unRX_FIFO_STATUS.stcField.u9USED = 1u /// /// - Expectations: /// /// \output CddMlcUart_unSendReceive_Iterator = 1u /// \output CddMlcUart_Buffer[0u].sStatus.boEntryUsed = FALSE /// \output CddMlcUart_Buffer[0u].sStatus.boRxSuccess = TRUE /// \output CddMlcUart_boIsUartReady = TRUE /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values //CddMlcUart_boMsgSent = TRUE; CddMlcUart_unSendReceive_Iterator = 0u; CddMlcUart_boRxSuccess = TRUE; CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].sStatus.boEntryUsed = FALSE; CddMlcUart_Buffer[1u].sStatus.boEntryUsed = FALSE; CddMlcUart_boIsUartReady = FALSE; SCB_UART->unRX_FIFO_STATUS.stcField.u9USED = 1u; //Step 3) Call FUT CddMlcUart_SendReceived_Irq(); //Step 4) Check expected output values //AL_UNITTEST_CHECK(CddMlcUart_boMsgSent, FALSE, == ); AL_UNITTEST_CHECK(CddMlcUart_unSendReceive_Iterator, 1u, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0u].sStatus.boEntryUsed, FALSE, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0u].sStatus.boRxSuccess, TRUE, == ); AL_UNITTEST_CHECK(CddMlcUart_boIsUartReady, TRUE, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase2 /// /// \Test Case Description /// - Test subject: Test if the callback function sends the message /// already in the queue and sets the DMA flags as ready /// /// - Preconditions: /// /// \input CddMlcUart_boMsgSent = FALSE /// \input CddMlcUart_unSendReceive_Iterator = 0u /// \input CddMlcUart_boRxSuccess = TRUE /// \input CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].sStatus.boEntryUsed = FALSE /// \input CddMlcUart_Buffer[1u].sStatus.boEntryUsed = TRUE /// \input SCB_UART->unRX_FIFO_STATUS.stcField.u9USED = 1u /// /// - Expectations: /// /// \output CddMlcUart_boMsgSent = TRUE /// \output CddMlcUart_unSendReceive_Iterator = 1u /// \output CddMlcUart_Buffer[0u].sStatus.boEntryUsed = FALSE /// \output CddMlcUart_Buffer[0u].sStatus.boRxSuccess = TRUE /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values //CddMlcUart_boMsgSent = FALSE; CddMlcUart_unSendReceive_Iterator = 0u; CddMlcUart_boRxSuccess = TRUE; CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].sStatus.boEntryUsed = FALSE; CddMlcUart_Buffer[1u].sStatus.boEntryUsed = TRUE; SCB_UART->unRX_FIFO_STATUS.stcField.u9USED = 1u; //Step 3) Call FUT CddMlcUart_SendReceived_Irq(); //Step 4) Check expected output values //AL_UNITTEST_CHECK(CddMlcUart_boMsgSent, TRUE, == ); AL_UNITTEST_CHECK(CddMlcUart_unSendReceive_Iterator, 1u, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0u].sStatus.boEntryUsed, FALSE, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0u].sStatus.boRxSuccess, TRUE, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase2 /// /// \Test Case Description /// - Test subject: Test if the callback function sends the message /// already in the queue and sets the DMA flags as ready /// /// - Preconditions: /// /// \input CddMlcUart_boMsgSent = FALSE /// \input CddMlcUart_unSendReceive_Iterator = 0u /// \input CddMlcUart_boRxSuccess = TRUE /// \input CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].sStatus.boEntryUsed = FALSE /// \input CddMlcUart_Buffer[1u].sStatus.boEntryUsed = TRUE /// \input SCB_UART->unRX_FIFO_STATUS.stcField.u9USED = 1u /// /// - Expectations: /// /// \output CddMlcUart_boMsgSent = TRUE /// \output CddMlcUart_unSendReceive_Iterator = 1u /// \output CddMlcUart_Buffer[0u].sStatus.boEntryUsed = FALSE /// \output CddMlcUart_Buffer[0u].sStatus.boRxSuccess = TRUE /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase3(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values //CddMlcUart_boMsgSent = FALSE; CddMlcUart_unSendReceive_Iterator = 0u; CddMlcUart_boRxSuccess = TRUE; CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].sStatus.boEntryUsed = FALSE; CddMlcUart_Buffer[CddMlcUart_unSendReceive_Iterator].pucRxData = NULL; CddMlcUart_Buffer[1u].sStatus.boEntryUsed = TRUE; SCB_UART->unRX_FIFO_STATUS.stcField.u9USED = 1u; //Step 3) Call FUT CddMlcUart_SendReceived_Irq(); //Step 4) Check expected output values //AL_UNITTEST_CHECK(CddMlcUart_boMsgSent, TRUE, == ); AL_UNITTEST_CHECK(CddMlcUart_unSendReceive_Iterator, 1u, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0u].sStatus.boEntryUsed, FALSE, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0u].sStatus.boRxSuccess, TRUE, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase /// /// \Test Case Description /// - Test subject: Test the callback function called from DMA interrupt /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase(void) { Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase1(); Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase2(); Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase3(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_AddMessage_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function checks if there is space in the ringbuffer /// adds the message to the ringbuffer, checks if dma channels are free /// and returns the status of the message /// /// - Preconditions: /// /// \input CddMlcUart_AddMessage_Param2 = 0 /// \input CddMlcUart_AddMessage_Param4 = 1 /// \input CddMlcUart_AddMessage_Param1 = &CddMlcUart_AddMessage_Param4 /// \input CddMlcUart_AddMessage_Param3 = &CddMlcUart_AddMessage_Param4 /// \input CddMlcUart_Buffer[0].sStatus.boEntryUsed = FALSE (0u) /// \input CddMlcUart_boIsUartReady = TRUE (1u) /// \output CddMlcUart_Buffer[0].pucTxData = 0u /// \output CddMlcUart_Buffer[0].pucRxData = 0u /// \output CddMlcUart_Buffer[0].ucRxSize = 0u /// \output CddMlcUart_Buffer[0].ucTxSize = 1u /// \output CddMlcUart_Buffer[0].sStatus.boEntryUsed = 0u /// \output CddMlcUart_Buffer[0].sStatus.boRxSuccess = 1u /// \output CddMlcUart_Buffer[0].sStatus.boBitError = 1u /// \output CddMlcUart_Buffer[0].sStatus.boFramingError = 1u /// \output CddMlcUart_Buffer[0].sStatus.boOverrunError = 1u /// \output CddMlcUart_boIsUartReady = 1u /// \output CddMlcUart_unAddMessage_Iterator = 0u /// \output CddMlcUart_AddMessage_RetVal = 0u /// /// /// - Expectations: /// /// \output CddMlcUart_Buffer[0].pucTxData = CddMlcUart_AddMessage_Param1 /// \output CddMlcUart_Buffer[0].pucRxData = CddMlcUart_AddMessage_Param3 /// \output CddMlcUart_Buffer[0].ucRxSize = CddMlcUart_AddMessage_Param4 /// \output CddMlcUart_Buffer[0].ucTxSize = CddMlcUart_AddMessage_Param2 /// \output CddMlcUart_Buffer[0].sStatus.boEntryUsed = 1u /// \output CddMlcUart_Buffer[0].sStatus.boRxSuccess = 0u /// \output CddMlcUart_Buffer[0].sStatus.boBitError = 0u /// \output CddMlcUart_Buffer[0].sStatus.boFramingError = 0u /// \output CddMlcUart_Buffer[0].sStatus.boOverrunError = 0u /// \output CddMlcUart_boIsUartReady = 0u /// \output CddMlcUart_unAddMessage_Iterator = 1u /// \output CddMlcUart_AddMessage_RetVal = &CddMlcUart_Buffer[0].sStatus /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_AddMessage_TestCase1(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values SCB_UART->unRX_FIFO_CTRL.stcField.u8TRIGGER_LEVEL = 7u; SCB_UART->unTX_FIFO_WR.u32Register = 0u; CddMlcUart_AddMessage_Param2 = 0; CddMlcUart_AddMessage_Param4 = 1; CddMlcUart_AddMessage_Param1 = &CddMlcUart_AddMessage_Param4; CddMlcUart_AddMessage_Param3 = &CddMlcUart_AddMessage_Param4; CddMlcUart_Buffer[0].sStatus.boEntryUsed = FALSE; CddMlcUart_Buffer[0].pucTxData = 0u; CddMlcUart_Buffer[0].pucRxData = 0u; CddMlcUart_Buffer[0].ucRxSize = 0u; CddMlcUart_Buffer[0].ucTxSize = 1u; CddMlcUart_Buffer[0].sStatus.boEntryUsed = 0u; CddMlcUart_Buffer[0].sStatus.boRxSuccess = 1u; CddMlcUart_Buffer[0].sStatus.boBitError = 1u; CddMlcUart_Buffer[0].sStatus.boFramingError = 1u; CddMlcUart_Buffer[0].sStatus.boOverrunError = 1u; CddMlcUart_unAddMessage_Iterator = 0u; CddMlcUart_AddMessage_RetVal = 0u; //Step 3) Call FUT CddMlcUart_AddMessage_RetVal = CddMlcUart_AddMessage(CddMlcUart_AddMessage_Param1, CddMlcUart_AddMessage_Param2, CddMlcUart_AddMessage_Param3, CddMlcUart_AddMessage_Param4); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].pucTxData, CddMlcUart_AddMessage_Param1, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].pucRxData, CddMlcUart_AddMessage_Param3, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].ucRxSize, CddMlcUart_AddMessage_Param4, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].ucTxSize, CddMlcUart_AddMessage_Param2, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].sStatus.boEntryUsed, 1u, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].sStatus.boRxSuccess, 0u, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].sStatus.boBitError, 0u, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].sStatus.boFramingError, 0u, == ); AL_UNITTEST_CHECK(CddMlcUart_Buffer[0].sStatus.boOverrunError, 0u, == ); AL_UNITTEST_CHECK(CddMlcUart_unAddMessage_Iterator, 1u, == ); AL_UNITTEST_CHECK(CddMlcUart_AddMessage_RetVal, &CddMlcUart_Buffer[0].sStatus, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_AddMessage_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function checks if there is space in the ringbuffer /// /// - Preconditions: /// /// \input CddMlcUart_AddMessage_Param2 = 1 /// \input CddMlcUart_AddMessage_Param4 = 0 /// \input CddMlcUart_AddMessage_RetVal = &CddMlcUart_AddMessage_Param2 /// /// - Expectations: /// /// \output CddMlcUart_AddMessage_RetVal = NULL_PTR (0u) /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_AddMessage_TestCase2(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlcUart_AddMessage_Param2 = 1; CddMlcUart_AddMessage_Param4 = 0; CddMlcUart_AddMessage_RetVal = &CddMlcUart_AddMessage_Param2; //Step 3) Call FUT CddMlcUart_AddMessage_RetVal = CddMlcUart_AddMessage(CddMlcUart_AddMessage_Param1, CddMlcUart_AddMessage_Param2, CddMlcUart_AddMessage_Param3, CddMlcUart_AddMessage_Param4); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcUart_AddMessage_RetVal, NULL_PTR, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_AddMessage_TestCase /// /// \Test Case Description /// - Test subject: Verify the ringbuffer, add messages to the queue and /// prepare the DMA channels /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_AddMessage_TestCase(void) { Mt_CddMlc_CddMlcUart_AddMessage_TestCase1(); Mt_CddMlc_CddMlcUart_AddMessage_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_IRQ_CddMlc_Uart_IRQ3_TestCase /// /// \Test Case Description /// - Test subject: Verify UART Irq is called /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_IRQ_CddMlc_Uart_IRQ3_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values SCB_UART->unINTR_CAUSE.stcField.u1RX = 0U; CddMlcUart_boRxSuccess = FALSE; //Step 3) Call FUT ISR_CddMlc_Uart_IRQ3(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcUart_boRxSuccess, FALSE, == ); //Step 1: Set pre-conditions //Step 2) Assign Input values SCB_UART->unINTR_CAUSE.stcField.u1RX = 1U; CddMlcUart_boRxSuccess = FALSE; //Step 3) Call FUT ISR_CddMlc_Uart_IRQ3(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcUart_boRxSuccess, TRUE, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function returns when message was sent and /// timeout conditions are not met /// /// - Preconditions: /// /// \input Gpt_GetTimeElapsed = FALSE /// \input CddMlcUart_boMsgSent = TRUE /// \input CddMlcUart_boIsDmaReady = FALSE /// \input CddMlcUart_boRxSuccess = FALSE /// /// - Expectations: /// /// \output CddMlcUart_boIsDmaReady = FALSE /// \output CddMlcUart_boRxSuccess = FALSE /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase1(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values //Gpt_GetTimeElapsed_Param1 = 0; Gpt_GetTimeElapsed_RetVal = FALSE; CddMlcUart_boMsgSent = TRUE; CddMlcUart_boIsUartReady = FALSE; CddMlcUart_boRxSuccess = FALSE; Gpt_GetTimeElapsed_HitCount = 0u; //Step 3) Call FUT CddMlcUart_CommLossHandling(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcUart_boIsUartReady, FALSE, == ); AL_UNITTEST_CHECK(CddMlcUart_boRxSuccess, FALSE, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function calls interrupt handler when timeout /// occured /// /// - Preconditions: /// /// \input CddMlcUart_CommandStart = 0xFFFFFFFFu /// \input CddMlcUart_boMsgSent = TRUE /// \input CddMlcUart_boIsUartReady = FALSE /// \input CddMlcUart_boRxSuccess = FALSE /// \input Gpt_GetTimeElapsed_HitCount = 0u /// /// - Expectations: /// /// \output boTimeout = TRUE /// \output CddMlcUart_boMsgSent = FALSE /// \output CddMlcUart_boIsUartReady = TRUE /// \output CddMlcUart_boRxSuccess = FALSE /// \output Gpt_GetTimeElapsed_HitCount = 1u //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase2(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlcUart_CommandStart = 0xFFFFFFFFu; // Gpt_GetTimeElapsed_Param1 = 0xFFFFFFFFu; CddMlcUart_boMsgSent = TRUE; CddMlcUart_boIsUartReady = FALSE; CddMlcUart_boRxSuccess = FALSE; Gpt_GetTimeElapsed_HitCount = 0u; Gpt_GetTimeElapsed_RetVal = FALSE; //Step 3) Call FUT CddMlcUart_CommLossHandling(); //Step 4) Check expected output values AL_UNITTEST_CHECK(boTimeout, TRUE, == ); AL_UNITTEST_CHECK(CddMlcUart_boMsgSent, TRUE, == ); AL_UNITTEST_CHECK(CddMlcUart_boIsUartReady, TRUE, == ); AL_UNITTEST_CHECK(CddMlcUart_boRxSuccess, FALSE, == ); AL_UNITTEST_CHECK(Gpt_GetTimeElapsed_HitCount, 3u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase /// /// \Test Case Description /// - Test subject: Verify communication timeout /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase(void) { Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase1(); Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_ControlUartCommunication_TestCase /// /// \Test Case Description /// - Test subject: Test if function controls the UART communicatiob /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_ControlUartCommunication_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlcUart_ControlUartCommunication_Param1 = TRUE; //Step 3) Call FUT CddMlcUart_ControlUartCommunication(CddMlcUart_ControlUartCommunication_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unCTRL.stcField.u1ENABLED, 1u, == ); //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlcUart_ControlUartCommunication_Param1 = FALSE; //Step 3) Call FUT CddMlcUart_ControlUartCommunication(CddMlcUart_ControlUartCommunication_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unCTRL.stcField.u1ENABLED, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_MaskUartInterrupt_TestCase /// /// \Test Case Description /// - Test subject: Test if function masks the interrupt /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_MaskUartInterrupt_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values SCB_UART->unINTR_RX_MASK.stcField.u1TRIGGER = 1u; //Step 3) Call FUT CddMlcUart_MaskUartInterrupt(); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unINTR_RX_MASK.stcField.u1TRIGGER, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_UnmaskUartInterrupt_TestCase /// /// \Test Case Description /// - Test subject: Test if function unmasks the interrupt /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_UnmaskUartInterrupt_TestCase(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values SCB_UART->unINTR_RX.stcField.u1TRIGGER = 0u; SCB_UART->unINTR_RX_MASK.stcField.u1TRIGGER = 0u; //Step 3) Call FUT CddMlcUart_UnmaskUartInterrupt(); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unINTR_RX.stcField.u1TRIGGER, 1u, == ); AL_UNITTEST_CHECK(SCB_UART->unINTR_RX_MASK.stcField.u1TRIGGER, 1u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function reads the content from Rx FIFO and /// stores the data /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase1(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values uint8 Mt_ReadFifo_Data[32] = { 0u }; SCB_UART->unRX_FIFO_STATUS.stcField.u9USED = 5u; SCB_UART->unRX_FIFO_RD.u32Register = 0xAA55; CddMlcUart_ReadRxFifo_Param1 = &Mt_ReadFifo_Data; //Step 3) Call FUT CddMlcUart_ReadRxFifo(CddMlcUart_ReadRxFifo_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(*CddMlcUart_ReadRxFifo_Param1, 0x55u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function clears the content from Rx FIFO if /// the function parameter is NULL_PTR /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase2(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlcUart_ReadRxFifo_Param1 = NULL_PTR; SCB_UART->unRX_FIFO_CTRL.stcField.u1CLEAR = 1u; //Step 3) Call FUT CddMlcUart_ReadRxFifo(CddMlcUart_ReadRxFifo_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unRX_FIFO_CTRL.stcField.u1CLEAR, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase /// /// \Test Case Description /// - Test subject: Test if the function handles RX FIFO register /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase(void) { Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase1(); Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function writes in Tx FIFO the given data /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase1(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values uint8 Mt_WriteFifo_Data[11] = { 0xE1, 0xA5, 0xFF, 0xE1, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 }; SCB_UART->unTX_FIFO_WR.u32Register = 0u; CddMlcUart_FillTxFifo_Param1 = &Mt_WriteFifo_Data; CddMlcUart_FillTxFifo_Param2 = 2u; //Step 3) Call FUT CddMlcUart_FillTxFifo(CddMlcUart_FillTxFifo_Param1, CddMlcUart_FillTxFifo_Param2); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unTX_FIFO_WR.u32Register, 0xA5, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function clears the content from Tx FIFO if /// the function parameter is NULL_PTR /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase2(void) { //Step 1: Set pre-conditions //Step 2) Assign Input values CddMlcUart_FillTxFifo_Param1 = NULL_PTR; SCB_UART->unTX_FIFO_CTRL.stcField.u1CLEAR = 1u; //Step 3) Call FUT CddMlcUart_FillTxFifo(CddMlcUart_FillTxFifo_Param1, CddMlcUart_FillTxFifo_Param2); //Step 4) Check expected output values AL_UNITTEST_CHECK(SCB_UART->unTX_FIFO_CTRL.stcField.u1CLEAR, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase /// /// \Test Case Description /// - Test subject: Test if the function handles TX FIFO register /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase(void) { Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase1(); Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase2(); } //============================================================================= // CddMlcGen.c //============================================================================= //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_Init_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function calls the correct init function depending /// on the input matrix type - TI device /// /// - Preconditions: /// /// \input CddMlcGen_Init_Param1 = eMlcDevice_MLC_DEVICE_TI /// \input CddMlcGenAPIs[CddMlcGen_Init_Param1].init = &CddMlcGen_Init_Param1 /// \input CddMlc_SystemMode = CddMlc_SystemMode_Inactive /// /// - Expectations: /// /// \output CddMlc_SystemMode = CddMlc_SystemMode_CfgComm /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_Init_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGen_Init_Param1 = eMlcDevice_MLC_DEVICE_TI; gCddMlcGenAPIs[CddMlcGen_Init_Param1].init = &CddMlcGen_Init_Param1; CddMlc_SystemMode = CddMlc_SystemMode_Inactive; //Step 3) Call FUT CddMlcGen_Init(CddMlcGen_Init_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgComm, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_Init_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function skips calling the init function /// if maximum number of devices was reached /// /// - Preconditions: /// /// \input CddMlcGen_Init_Param1 = eMlcDeviceMax /// \input CddMlcGenAPIs[CddMlcGen_Init_Param1].init = &CddMlcGen_Init_Param1 /// \input CddMlc_SystemMode = CddMlc_SystemMode_Inactive /// /// - Expectations: /// /// \output CddMlc_SystemMode = CddMlc_SystemMode_Inactive /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_Init_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGen_Init_Param1 = eMlcDeviceMax; gCddMlcGenAPIs[CddMlcGen_Init_Param1].init = &CddMlcGen_Init_Param1; CddMlc_SystemMode = CddMlc_SystemMode_Inactive; //Step 3) Call FUT CddMlcGen_Init(CddMlcGen_Init_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_Inactive, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_Init_TestCase /// /// \Test Case Description /// - Test subject: Verify that the module is correctly initialized /// depending on the device type /// /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_Init_TestCase(void) { Mt_CddMlc_CddMlcGen_Init_TestCase1(); Mt_CddMlc_CddMlcGen_Init_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_Cyclic_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function executes the cyclic routine depending /// on the input matrix type - TI device and updates RTE commands /// /// - Preconditions: /// /// \input CddMlcGen_Cyclic_Param1 = eMlcDevice_MLC_DEVICE_TI /// \input CddMlcGenAPIs[CddMlcGen_Cyclic_Param1].cyclic = &CddMlcGen_Cyclic_Param1 /// \input CddMlc_SystemMode = CddMlc_SystemMode_CfgComm /// /// - Expectations: /// /// \output CddMlc_SystemMode = CddMlc_SystemMode_CfgChips /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_Cyclic_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGen_Cyclic_Param1 = eMlcDevice_MLC_DEVICE_TI; gCddMlcGenAPIs[CddMlcGen_Cyclic_Param1].cyclic = &CddMlcGen_Cyclic_Param1; CddMlc_SystemMode = CddMlc_SystemMode_CfgComm; //Step 3) Call FUT CddMlcGen_Cyclic(CddMlcGen_Cyclic_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgChips, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_Cyclic_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function skips calling the cyclic function /// if the function is invalid /// /// - Preconditions: /// /// \input CddMlcGen_Cyclic_Param1 = eMlcDeviceMax /// \input CddMlcGenAPIs[CddMlcGen_Cyclic_Param1].cyclic = NULL_PTR /// /// - Expectations: /// /// \output /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_Cyclic_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGen_Cyclic_Param1 = eMlcDeviceMax; gCddMlcGenAPIs[CddMlcGen_Cyclic_Param1].cyclic = NULL_PTR; //Step 3) Call FUT CddMlcGen_Cyclic(CddMlcGen_Cyclic_Param1); //Step 4) Check expected output values // nothing to be checked, returns from function } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_Cyclic_TestCase /// /// \Test Case Description /// - Test subject: Verify that the correct cycle routine is executed /// depending on the MLC device type /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_Cyclic_TestCase(void) { Mt_CddMlc_CddMlcGen_Cyclic_TestCase1(); Mt_CddMlc_CddMlcGen_Cyclic_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function returns the PWM target values /// assigned to the device type (TPS92662) /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \input CddMlc_unTargetLedWidths_List[0u][0u] = 0x55u /// /// - Expectations: /// /// \output CddMlcGen_GetTargetBufAddress_RetVal = &CddMlc_unTargetLedWidths_List[0u][0u] /// \output *CddMlcGen_GetTargetBufAddress_RetVal = 0x55u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlc_unTargetLedWidths_List[0u][0u] = 0x55u; //Step 3) Call FUT CddMlcGen_GetTargetBufAddress_RetVal = CddMlcGen_GetTargetBufAddress(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGen_GetTargetBufAddress_RetVal, &CddMlc_unTargetLedWidths_List[0u][0u], ==); AL_UNITTEST_CHECK(*CddMlcGen_GetTargetBufAddress_RetVal, 0x55u, ==); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function returns the PWM target values /// assigned to the device type (NXP_ASL5115SHN) /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP /// /// - Expectations: /// /// \output /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP; //CddMlc_unTargetLedWidths_List[0u][0u] = 0x55u; //Step 3) Call FUT CddMlcGen_GetTargetBufAddress_RetVal = CddMlcGen_GetTargetBufAddress(); //Step 4) Check expected output values // AL_UNITTEST_CHECK(); // ToDo: add checking when NXP device is available } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase /// /// \Test Case Description /// - Test subject: Verify that the function returns the target values /// for the selected matrix type /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase(void) { Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase1(); Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function sets communication inactive if /// requested for NXP matrix type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP /// /// - Expectations: /// /// \output /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP; //Step 3) Call FUT CddMlcGen_SetTransmissionToInactive(); //Step 4) Check expected output values //nothing to be checked, returns from function } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function sets communication inactive if /// requested for TI matrix type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \input CddMlc_SystemMode = CddMlc_SystemMode_Powerup /// /// - Expectations: /// /// \output CddMlc_SystemMode = CddMlc_SystemMode_Inactive /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlc_SystemMode = CddMlc_SystemMode_Powerup; //Step 3) Call FUT CddMlcGen_SetTransmissionToInactive(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_Inactive, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase /// /// \Test Case Description /// - Test subject: Verify that the communication mode is set to inactive /// for the selected matrix type /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase(void) { Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase1(); Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function enables communication if /// requested for NXP matrix type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP /// \input /// /// - Expectations: /// /// \output /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP; //Step 3) Call FUT CddMlcGen_SetTransmissionToNormal(); //Step 4) Check expected output values // AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgComm, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function enables communication if /// requested for TI matrix type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \input CddMlc_SystemMode = CddMlc_SystemMode_Powerup /// /// - Expectations: /// /// \output CddMlc_SystemMode = CddMlc_SystemMode_CfgComm /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlc_SystemMode = CddMlc_SystemMode_Powerup; //Step 3) Call FUT CddMlcGen_SetTransmissionToNormal(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgComm, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase /// /// \Test Case Description /// - Test subject: Verify that the communication is started for the /// selected matrix type /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase(void) { Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase1(); Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function returns the converted PWM value on 12-bit /// resolution accepted by NXP device type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP /// \input CddMlcGen_ConvertToRawValue_Param1 = 0x100u /// /// - Expectations: /// /// \output CddMlcGen_ConvertToRawValue_RetVal = 0x1Fu /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP; CddMlcGen_ConvertToRawValue_Param1 = 0x100u; //Step 3) Call FUT CddMlcGen_ConvertToRawValue_RetVal = CddMlcGen_ConvertToRawValue(CddMlcGen_ConvertToRawValue_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGen_ConvertToRawValue_RetVal, 0x1Fu, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function returns the converted PWM value on 10-bit /// resolution accepted by TI device type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \input CddMlcGen_ConvertToRawValue_Param1 = 0x100u /// /// - Expectations: /// /// \output CddMlcGen_ConvertToRawValue_RetVal = 0x7u /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlcGen_ConvertToRawValue_Param1 = 0x100u; //Step 3) Call FUT CddMlcGen_ConvertToRawValue_RetVal = CddMlcGen_ConvertToRawValue(CddMlcGen_ConvertToRawValue_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGen_ConvertToRawValue_RetVal, 0x7u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase /// /// \Test Case Description /// - Test subject: Verify that the function converts the PWM value for /// the selected matrix type /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase(void) { Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase1(); Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function returns the converted PWM value percentage /// accepted by NXP device type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP /// \input CddMlcGen_ConvertDiagToRawValue_Param1 = 100u /// /// - Expectations: /// /// \output CddMlcGen_ConvertDiagToRawValue_RetVal = 0xFFFu /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP; CddMlcGen_ConvertDiagToRawValue_Param1 = 100u; //Step 3) Call FUT CddMlcGen_ConvertDiagToRawValue_RetVal = CddMlcGen_ConvertDiagToRawValue(CddMlcGen_ConvertDiagToRawValue_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGen_ConvertDiagToRawValue_RetVal, 0xFFFu, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function returns the converted PWM value percentage /// accepted by TI device type /// /// - Preconditions: /// /// \input CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \input CddMlcGen_ConvertDiagToRawValue_Param1 = 100u /// /// - Expectations: /// /// \output CddMlcGen_ConvertDiagToRawValue_RetVal = 0x3FFu /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlcGen_ConvertDiagToRawValue_Param1 = 100u; //Step 3) Call FUT CddMlcGen_ConvertDiagToRawValue_RetVal = CddMlcGen_ConvertDiagToRawValue(CddMlcGen_ConvertDiagToRawValue_Param1); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGen_ConvertDiagToRawValue_RetVal, 0x3FFu, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase /// /// \Test Case Description /// - Test subject: Verify that the function converts the PWM value for /// the selected matrix type /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase(void) { Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase1(); Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase2(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_riCddMlcInit_TestCase /// /// \Test Case Description: Test if riCddMlcInit calls correctly CddMlc_Init function. /// /// - Preconditions: /// /// \input /// /// - Expectations: /// /// \output //----------------------------------------------------------------------------- void Mt_CddMlc_riCddMlcInit_TestCase(void) { //Step 3) Call FUT riCddMlcInit(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_riCddMlcDeInit_TestCase /// /// \Test Case Description: Test if riCddMlcInit calls correctly CddMlc_DeInit function. /// /// - Preconditions: /// /// \input /// /// - Expectations: /// /// \output //----------------------------------------------------------------------------- void Mt_CddMlc_riCddMlcDeInit_TestCase(void) { //Step 3) Call FUT rdCddMlcDeInit(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_EvaluateCoding_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function skips reading coding parameters in case /// the coding status read from CodM is invalid (no coding available) /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input eCodingPrevStatus = tieDataStatus_Valid /// /// - Expectations: /// /// \output eCodingPrevStatus = tieDataStatus_Invalid /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_EvaluateCoding_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values eCodingPrevStatus = tieDataStatus_Valid; //Step 3) Call FUT CddMlc_EvaluateCoding(); //Step 4) Check expected output values AL_UNITTEST_CHECK(eCodingPrevStatus, tieDataStatus_Invalid, ==); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_EvaluateCoding_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function reads coding parameters for the /// selected device type (NXP or TI) /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input pplicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \input eCodingPrevStatus = tieDataStatus_Invalid /// \input CddMlc_boOperationEnabled = FALSE /// \input CddMlc_boActionToExecuteAfterNewConfig = FALSE /// /// - Expectations: /// /// \output eCodingPrevStatus = tieDataStatus_Valid /// \output CddMlc_boOperationEnabled = TRUE /// \output CddMlc_boActionToExecuteAfterNewConfig = TRUE /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_EvaluateCoding_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlc_boOperationEnabled = FALSE; CddMlc_boActionToExecuteAfterNewConfig = FALSE; eCodingPrevStatus = tieDataStatus_Invalid; //Step 3) Call FUT CddMlc_EvaluateCoding(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_boOperationEnabled, TRUE, ==); AL_UNITTEST_CHECK(CddMlc_boActionToExecuteAfterNewConfig, TRUE, ==); AL_UNITTEST_CHECK(eCodingPrevStatus, tieDataStatus_Valid, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_EvaluateCoding_TestCase3 /// /// \Test Case Description /// - Test subject: Test if function reads coding parameters for the /// selected device type (NXP or TI), but does not enable /// further operations if no MLC is connected /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_DISABLED /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM__UART_CAN_ADDRESSES[ucIdx] = MLC_DEV_ADDR_NOT_CONNECTED (ucIdx < 3) /// \input applicationCodingData.eCodingState = tieDataStatus_Valid /// \input eCodingPrevStatus = tieDataStatus_Invalid /// \input CddMlc_boOperationEnabled = FALSE /// \input CddMlc_boActionToExecuteAfterNewConfig = FALSE /// \input CddMlcGenCodingDataValue.ucMlcMatrixCount = 0u /// /// - Expectations: /// /// \output eCodingPrevStatus = tieDataStatus_Valid /// \output CddMlc_boOperationEnabled = FALSE /// \output CddMlc_boActionToExecuteAfterNewConfig = TRUE /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_EvaluateCoding_TestCase3(void) //no matrix connected { //Step 1) Set pre-conditions //Step 2) Assign Input values for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_UART_CAN_ADDRESS[ucIdx] = MLC_DEV_ADDR_NOT_CONNECTED; } applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_DISABLED; CddMlc_boOperationEnabled = FALSE; CddMlc_boActionToExecuteAfterNewConfig = FALSE; eCodingPrevStatus = tieDataStatus_Invalid; CddMlcGenCodingDataValue.ucMlcMatrixCount = 0u; //Step 3) Call FUT CddMlc_EvaluateCoding(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_boOperationEnabled, FALSE, == ); AL_UNITTEST_CHECK(CddMlc_boActionToExecuteAfterNewConfig, TRUE, == ); AL_UNITTEST_CHECK(eCodingPrevStatus, tieDataStatus_Valid, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlc_EvaluateCoding_TestCase /// /// \Test Case Description /// - Test subject: Verify the status of coding parameters and proceed to /// reading them if valid. /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlc_EvaluateCoding_TestCase(void) { // Mt_CddMlc_CddMlc_EvaluateCoding_TestCase1(); //not possible to achieve eCodingPrevStatus valid, because we are not manipulating coding status Mt_CddMlc_CddMlc_EvaluateCoding_TestCase2(); Mt_CddMlc_CddMlc_EvaluateCoding_TestCase3(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase1 /// /// \Test Case Description /// - Test subject: Test if function reads coding parameters and in case of /// unknown matrix type returned by coding, sets undefined matrix type /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_DISABLED /// /// - Expectations: /// /// \output CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_DISABLED /// \output CddMlcGenCodingDataValue.ucMlcSwitchsSupported = 0u /// \output CddMlcGen_GetCodingParam_RetVal = eMlcDeviceMax /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_DISABLED; CddMlcGenCodingDataValue.ucMlcSwitchsSupported = 0u; //Step 3) Call FUT CddMlcGen_GetCodingParam_RetVal = CddMlcGen_GetCodingParam(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcMatrixType, CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_DISABLED, == ); AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcSwitchsSupported, 0u, == ); AL_UNITTEST_CHECK(CddMlcGen_GetCodingParam_RetVal, eMlcDeviceMax, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase2 /// /// \Test Case Description /// - Test subject: Test if function reads coding parameters and extracts useful /// information for the selected device and returns the MLC connected device type (TPS92662A) /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \input CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM__UART_CAN_ADDRESSES[ucDevNr] = MLC_DEV_ADDR_NOT_CONNECTED (ucDevNr < 3) /// /// - Expectations: /// /// \output CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A /// \output CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN /// \output CddMlcGenCodingDataValue.ucMlcCanUartAddress[ucDevNr] = MLC_DEV_ADDR_NOT_CONNECTED (ucDevNr < 7) /// \output CddMlcGenCodingDataValue.ucMlcSwitchsSupported = CDD_MLC_TPS92662A_MAX_SWITCHS_PER_DEVICE /// \output CddMlcGen_GetCodingParam_RetVal = eMlcDevice_MLC_DEVICE_TI /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN; for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_UART_CAN_ADDRESS[ucIdx] = MLC_DEV_ADDR_NOT_CONNECTED; } //Step 3) Call FUT CddMlcGen_GetCodingParam_RetVal = CddMlcGen_GetCodingParam(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcMatrixType, CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A, == ); AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcCanUartInterface, CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN, == ); for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcCanUartAddress[ucDevNr], MLC_DEV_ADDR_NOT_CONNECTED, == ); } AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcSwitchsSupported, CDD_MLC_TPS92662A_MAX_SWITCHS_PER_DEVICE, == ); AL_UNITTEST_CHECK(CddMlcGen_GetCodingParam_RetVal, eMlcDevice_MLC_DEVICE_TI, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase3 /// /// \Test Case Description /// - Test subject: Test if function reads coding parameters and extracts useful /// information for the selected device and returns the MLC connected device type (TPS92663A) /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92663A /// \input CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM__UART_CAN_ADDRESSES[ucDevNr] = MLC_DEV_ADDR_NOT_CONNECTED (ucDevNr < 7) /// /// - Expectations: /// /// \output CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92663A /// \output CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN /// \output CddMlcGenCodingDataValue.ucMlcCanUartAddress[ucDevNr] = MLC_DEV_ADDR_NOT_CONNECTED (ucDevNr < 7) /// \output CddMlcGenCodingDataValue.ucMlcSwitchsSupported = CDD_MLC_TPS92663A_MAX_SWITCHS_PER_DEVICE /// \output CddMlcGen_GetCodingParam_RetVal = eMlcDevice_MLC_DEVICE_TI /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase3(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92663A; CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN; for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_UART_CAN_ADDRESS[ucIdx] = MLC_DEV_ADDR_NOT_CONNECTED; } //Step 3) Call FUT CddMlcGen_GetCodingParam_RetVal = CddMlcGen_GetCodingParam(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcMatrixType, CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92663A, == ); AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcCanUartInterface, CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN, == ); for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcCanUartAddress[ucDevNr], MLC_DEV_ADDR_NOT_CONNECTED, == ); } AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcSwitchsSupported, CDD_MLC_TPS92663A_MAX_SWITCHS_PER_DEVICE, == ); AL_UNITTEST_CHECK(CddMlcGen_GetCodingParam_RetVal, eMlcDevice_MLC_DEVICE_TI, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase4 /// /// \Test Case Description /// - Test subject: Test if function reads coding parameters and extracts useful /// information for the selected device and returns the MLC connected device type (NXP_ASL5115SHN) /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92663A /// \input CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_SATELLITE_CAN /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM__UART_CAN_ADDRESSES[ucDevNr] = MLC_DEV_ADDR_NOT_CONNECTED (ucDevNr < 7) /// /// - Expectations: /// /// \output CddMlcGenCodingDataValue.ucMlcMatrixType = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP /// \output CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN /// \output CddMlcGenCodingDataValue.ucMlcCanUartAddress[ucDevNr] = MLC_DEV_ADDR_NOT_CONNECTED (ucDevNr < 7) /// \output CddMlcGenCodingDataValue.ucMlcSwitchsSupported = CDD_MLC_NXP_MAX_SWITCHS_PER_DEVICE /// \output CddMlcGen_GetCodingParam_RetVal = eMlcDevice_MLC_DEVICE_NXP /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase4(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP; CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_SATELLITE_CAN; for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_UART_CAN_ADDRESS[ucIdx] = MLC_DEV_ADDR_NOT_CONNECTED; } //Step 3) Call FUT CddMlcGen_GetCodingParam_RetVal = CddMlcGen_GetCodingParam(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcMatrixType, CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_NXP, == ); AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcCanUartInterface, CDDMLC_GEN_CODING_MATRIX_INTERFACE_PRIVATE_CAN, == ); for (uint8 ucDevNr = 0u; ucDevNr < CDD_MLC_CHIPS; ucDevNr++) { AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcCanUartAddress[ucDevNr], MLC_DEV_ADDR_NOT_CONNECTED, == ); } AL_UNITTEST_CHECK(CddMlcGenCodingDataValue.ucMlcSwitchsSupported, CDD_MLC_NXP_MAX_SWITCHS_PER_DEVICE, == ); AL_UNITTEST_CHECK(CddMlcGen_GetCodingParam_RetVal, eMlcDevice_MLC_DEVICE_NXP, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase /// /// \Test Case Description /// - Test subject: Read the coding parameters and save the information /// in an internal structure for the connected matrix /// //----------------------------------------------------------------------------- void Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase(void) { Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase1(); Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase2(); Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase3(); Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase4(); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_rpCddMlc_Cycle_TestCase1 /// /// \Test Case Description /// - Test subject: Test if the cyclic function checks the communication /// status each 1ms and handles comm. in case of errors /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCycleFrame = 1u /// \input CddMlcUart_boMsgSent = TRUE /// \input boTimeout = TRUE /// \input CddMlcUart_boIsDmaReady = FALSE /// \input CddMlcUart_boRxSuccess = FALSE /// /// - Expectations: /// /// \output CddMlc_ucCycleFrame = 2u /// \output CddMlcUart_boMsgSent = TRUE /// \output CddMlcUart_boRxSuccess = FALSE /// //----------------------------------------------------------------------------- void Mt_CddMlc_rpCddMlc1ms_TestCase1(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ucCycleFrame = 1u; CddMlcUart_boMsgSent = TRUE; boTimeout = TRUE; CddMlcUart_boIsUartReady = FALSE; CddMlcUart_boRxSuccess = FALSE; //Step 3) Call FUT rpCddMlc1ms(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCycleFrame, 2u, ==); AL_UNITTEST_CHECK(CddMlcUart_boMsgSent, TRUE, ==); AL_UNITTEST_CHECK(CddMlcUart_boRxSuccess, FALSE, ==); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_rpCddMlc_Cycle_TestCase2 /// /// \Test Case Description /// - Test subject: Test if the cyclic function initializes the selected MLC /// driver after reading valid coding parameters, but does not /// start the matrix functionality until the matrix is /// correctly powered /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCycleFrame = 10u /// \input CddMlc_boOperationEnabled = TRUE /// \input eCodingPrevStatus = tieDataStatus_Invalid /// \input CddMlc_SystemMode = CddMlc_SystemMode_Powerup /// \input CddMlc_LastSystemMode = CddMlc_SystemMode_Powerup /// \input Dio_ReadChannel_RetVal = TRUE /// \input CddMlcGen_ucPowerUpGuard = 1u /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM__UART_CAN_ADDRESSES[ucDevNr] = 0u (ucDevNr < 7u) /// /// - Expectations: /// /// \output CddMlc_ucCycleFrame = 1u /// \output CddMlc_boActionToExecuteAfterNewConfig = FALSE /// \output CddMlc_SystemMode = CddMlc_SystemMode_CfgComm /// \output CddMlc_LastSystemMode = CddMlc_SystemMode_CfgComm /// //----------------------------------------------------------------------------- void Mt_CddMlc_rpCddMlc1ms_TestCase2(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values // CddMlc_ucCycleFrame = 10u; CddMlc_ucCycleFrame = 0u; CddMlc_boOperationEnabled = TRUE; eCodingPrevStatus = tieDataStatus_Invalid; // applicationCodingData.eCodingState = tieDataStatus_Valid; CddMlc_SystemMode = CddMlc_SystemMode_Powerup; CddMlc_LastSystemMode = CddMlc_SystemMode_Powerup; Dio_ReadChannel_RetVal = TRUE; CddMlcGen_ucPowerUpGuard = 1u; applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; CddMlcGenCodingDataValue.ucMlcCanUartInterface = CDDMLC_GEN_CODING_MATRIX_INTERFACE_SATELLITE_CAN; for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_UART_CAN_ADDRESS[ucIdx] = 0u; } //Step 3) Call FUT rpCddMlc1ms(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCycleFrame, 1u, == ); AL_UNITTEST_CHECK(CddMlc_boActionToExecuteAfterNewConfig, FALSE, == ); AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgComm, == ); AL_UNITTEST_CHECK(CddMlc_LastSystemMode, CddMlc_SystemMode_CfgComm, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_rpCddMlc_Cycle_TestCase3 /// /// \Test Case Description /// - Test subject: Test if the cyclic function initializes the selected MLC /// driver after reading valid coding parameters, /// starts the matrix functionality after the matrix is /// correctly powered /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCycleFrame = 10u /// \input CddMlc_boOperationEnabled = TRUE /// \input eCodingPrevStatus = tieDataStatus_Valid /// \input CddMlc_SystemMode = CddMlc_SystemMode_Powerup /// \input CddMlc_LastSystemMode = CddMlc_SystemMode_Powerup /// \input Dio_ReadChannel_RetVal = TRUE /// \input CddMlcGen_ucPowerUpGuard = CDDMLC_POWERUP_CYCLE_GUARD /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM__UART_CAN_ADDRESSES[ucDevNr] = 0u (ucDevNr < 7u) /// /// - Expectations: /// /// \output CddMlc_ucCycleFrame = 1u /// \output CddMlc_boActionToExecuteAfterNewConfig = FALSE /// \output CddMlc_SystemMode = CddMlc_SystemMode_CfgComm /// \output CddMlc_LastSystemMode = CddMlc_SystemMode_CfgComm /// \output CddMlcGen_boMlcPoweredUP = TRUE /// //----------------------------------------------------------------------------- void Mt_CddMlc_rpCddMlc1ms_TestCase3(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ucCycleFrame = 10u; CddMlc_boOperationEnabled = TRUE; eCodingPrevStatus = tieDataStatus_Valid; // applicationCodingData.eCodingState = tieDataStatus_Valid; CddMlc_SystemMode = CddMlc_SystemMode_Powerup; CddMlc_LastSystemMode = CddMlc_SystemMode_Powerup; Dio_ReadChannel_RetVal = TRUE; CddMlcGen_ucPowerUpGuard = CDDMLC_POWERUP_CYCLE_GUARD; CddMlc_boActionToExecuteAfterNewConfig = FALSE; applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_CHIP_TYPE = CDDMLC_GEN_CODING_MATRIX_MLC_TYPE_TPS92662A; for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_UART_CAN_ADDRESS[ucIdx] = MLC_DEV_ADDR_NOT_CONNECTED; } //Step 3) Call FUT rpCddMlc1ms(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCycleFrame, 1u, == ); AL_UNITTEST_CHECK(CddMlc_boActionToExecuteAfterNewConfig, FALSE, == ); AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_CfgChips, == ); AL_UNITTEST_CHECK(CddMlc_LastSystemMode, CddMlc_SystemMode_CfgComm, == ); AL_UNITTEST_CHECK(CddMlcGen_boMlcPoweredUP, TRUE, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_rpCddMlc_Cycle_TestCase4 /// /// \Test Case Description /// - Test subject: Test if the cyclic function does bot execute the /// cycle routine if the matrix is not powered /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCycleFrame = 10u /// \input CddMlc_boOperationEnabled = TRUE /// \input eCodingPrevStatus = tieDataStatus_Invalid /// \input CddMlc_SystemMode = CddMlc_SystemMode_Powerup /// \input CddMlc_LastSystemMode = CddMlc_SystemMode_Powerup /// \input Dio_ReadChannel_RetVal = FALSE /// \input applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM__UART_CAN_ADDRESSES[ucDevNr] = 0u (ucDevNr < 7u) /// /// - Expectations: /// /// \output CddMlc_ucCycleFrame = 1u /// \output CddMlc_boActionToExecuteAfterNewConfig = FALSE /// \output CddMlc_SystemMode = CddMlc_SystemMode_Inactive /// \output CddMlc_LastSystemMode = CddMlc_SystemMode_Powerup /// \output CddMlcGen_boMlcPoweredUP = FALSE /// \output CddMlcGen_ucPowerUpGuard = 0u /// //----------------------------------------------------------------------------- void Mt_CddMlc_rpCddMlc1ms_TestCase4(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ucCycleFrame = 10u; CddMlc_boOperationEnabled = TRUE; eCodingPrevStatus = tieDataStatus_Valid; CddMlc_SystemMode = CddMlc_SystemMode_Powerup; CddMlc_LastSystemMode = CddMlc_SystemMode_Powerup; Dio_ReadChannel_RetVal = FALSE; CddMlc_boActionToExecuteAfterNewConfig = FALSE; for (uint8 ucIdx = 0u; ucIdx < CFG_MAX_NO_OF_MLC; ucIdx++) { applicationCodingData.LmmConfig.LMM_Config_Diagnosis.ucLMM_UART_CAN_ADDRESS[ucIdx] = MLC_DEV_ADDR_NOT_CONNECTED; } //Step 3) Call FUT rpCddMlc1ms(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCycleFrame, 1u, == ); AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_Inactive, == ); AL_UNITTEST_CHECK(CddMlc_LastSystemMode, CddMlc_SystemMode_Powerup, == ); AL_UNITTEST_CHECK(CddMlcGen_boMlcPoweredUP, FALSE, == ); AL_UNITTEST_CHECK(CddMlcGen_ucPowerUpGuard, 0u, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_rpCddMlc_Cycle_TestCase5 /// /// \Test Case Description /// - Test subject: Test if in case of no MLCs connected, the cycle routine /// is not performed /// /// - Test Design Technique: ET (Exploratory Testing) /// /// - Preconditions: /// /// \input CddMlc_ucCycleFrame = 10u /// \input CddMlc_boOperationEnabled = FALSE /// \input CddMlc_SystemMode = CddMlc_SystemMode_Inactive /// \input CddMlc_LastSystemMode = CddMlc_SystemMode_Inactive /// /// - Expectations: /// /// \output CddMlc_ucCycleFrame = 1u /// \output CddMlc_SystemMode = CddMlc_SystemMode_Inactive /// \output CddMlc_LastSystemMode = CddMlc_SystemMode_Inactive /// //----------------------------------------------------------------------------- void Mt_CddMlc_rpCddMlc1ms_TestCase5(void) { //Step 1) Set pre-conditions //Step 2) Assign Input values CddMlc_ucCycleFrame = 10u; CddMlc_boOperationEnabled = FALSE; CddMlc_SystemMode = CddMlc_SystemMode_Inactive; CddMlc_LastSystemMode = CddMlc_SystemMode_Inactive; //Step 3) Call FUT rpCddMlc1ms(); //Step 4) Check expected output values AL_UNITTEST_CHECK(CddMlc_ucCycleFrame, 1u, == ); AL_UNITTEST_CHECK(CddMlc_SystemMode, CddMlc_SystemMode_Inactive, == ); AL_UNITTEST_CHECK(CddMlc_LastSystemMode, CddMlc_SystemMode_Inactive, == ); } //----------------------------------------------------------------------------- /// \Test Case : Mt_CddMlc_rpCddMlc_Cycle_TestCase /// /// \Test Case Description /// - Test subject: Evaluate the conditions for executing the cycle /// routine for the connected MLC device /// //----------------------------------------------------------------------------- void Mt_CddMlc_rpCddMlc1ms_TestCase(void) { Mt_CddMlc_rpCddMlc1ms_TestCase1(); Mt_CddMlc_rpCddMlc1ms_TestCase2(); Mt_CddMlc_rpCddMlc1ms_TestCase3(); Mt_CddMlc_rpCddMlc1ms_TestCase4(); Mt_CddMlc_rpCddMlc1ms_TestCase5(); } //============================================================================= // Add Unit Tests //============================================================================= void ALUnitTest_AddTests(void) { //CddMlc.c ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_ResetMlcSettings_TestCase", Mt_CddMlc_CddMlc_ResetMlcSettings_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_ClearLedsStatus_TestCase", Mt_CddMlc_CddMlc_ClearLedsStatus_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_SetTransmissionToNormal_TestCase", Mt_CddMlc_CddMlc_SetTransmissionToNormal_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_SetTransmissionToInactive_TestCase", Mt_CddMlc_CddMlc_SetTransmissionToInactive_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_SetTransmissionActive_TestCase", Mt_CddMlc_CddMlc_SetTransmissionActive_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_SetTargetValues_TestCase", Mt_CddMlc_CddMlc_SetTargetValues_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_ScheduleCommands_TestCase", Mt_CddMlc_CddMlc_ScheduleCommands_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_ResetVars_TestCase", Mt_CddMlc_CddMlc_ResetVars_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_GetActualState_TestCase", Mt_CddMlc_CddMlc_GetActualState_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_GetActualValues_TestCase", Mt_CddMlc_CddMlc_GetActualValues_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_CddMlc_GetChipConfig_TestCase", Mt_CddMlc_CddMlc_GetChipConfig_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_GetADCResult_TestCase", Mt_CddMlc_CddMlc_GetADCResult_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_GetLedsStatus_TestCase", Mt_CddMlc_CddMlc_GetLedsStatus_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_GetComStatus_TestCase", Mt_CddMlc_CddMlc_GetComStatus_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_Cycle_TestCase", Mt_CddMlc_CddMlc_Cycle_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_StepToNextChip_TestCase", Mt_CddMlc_CddMlc_StepToNextChip_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_InterpretResponses_TestCase", Mt_CddMlc_CddMlc_InterpretResponses_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_CommandSuccess_TestCase", Mt_CddMlc_CddMlc_CommandSuccess_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_CommandFailed_TestCase", Mt_CddMlc_CddMlc_CommandFailed_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_CddMlc_ResponseHandler_TestCase", Mt_CddMlc_CddMlc_ResponseHandler_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_GetTargetBufAddress_TestCase", Mt_CddMlc_CddMlc_GetTargetBufAddress_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_MuxCommands_TestCase", Mt_CddMlc_CddMlc_MuxCommands_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase", Mt_CddMlc_CddMlc_GetMlcPhysicalAddress_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_BroadcastComm_TestCase", Mt_CddMlc_CddMlc_BroadcastComm_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_WriteCfgChips_TestCase", Mt_CddMlc_CddMlc_WriteCfgChips_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_WriteCfgPhases_TestCase", Mt_CddMlc_CddMlc_WriteCfgPhases_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_WriteCfgLeds_TestCase", Mt_CddMlc_CddMlc_WriteCfgLeds_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_WritePWMs_TestCase", Mt_CddMlc_CddMlc_WritePWMs_TestCase); //CddMlcUart ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_Init_TestCase", Mt_CddMlc_CddMlcUart_Init_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_StartSend_TestCase", Mt_CddMlc_CddMlcUart_StartSend_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase", Mt_CddMlc_CddMlcUart_SendReceived_Irq_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_AddMessage_TestCase", Mt_CddMlc_CddMlcUart_AddMessage_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_IRQ_CddMlc_Uart_IRQ3_TestCase", Mt_CddMlc_CddMlcUart_IRQ_CddMlc_Uart_IRQ3_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase", Mt_CddMlc_CddMlcUart_CommLossHandling_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_ControlUartCommunication_TestCase", Mt_CddMlc_CddMlcUart_ControlUartCommunication_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_ControlUartCommunication_TestCase", Mt_CddMlc_CddMlcUart_ControlUartCommunication_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_MaskUartInterrupt_TestCase", Mt_CddMlc_CddMlcUart_MaskUartInterrupt_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_UnmaskUartInterrupt_TestCase", Mt_CddMlc_CddMlcUart_UnmaskUartInterrupt_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase", Mt_CddMlc_CddMlcUart_ReadRxFifo_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase", Mt_CddMlc_CddMlcUart_FillTxFifo_TestCase); //CddMlcGen.c ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_Init_TestCase", Mt_CddMlc_CddMlcGen_Init_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_Cyclic_TestCase", Mt_CddMlc_CddMlcGen_Cyclic_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase", Mt_CddMlc_CddMlcGen_GetTargetBufAddress_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase", Mt_CddMlc_CddMlcGen_SetTransmissionToInactive_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase", Mt_CddMlc_CddMlcGen_SetTransmissionToNormal_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase", Mt_CddMlc_CddMlcGen_ConvertToRawValue_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase", Mt_CddMlc_CddMlcGen_ConvertDiagToRawValue_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_riCddMlcInit_TestCase", Mt_CddMlc_riCddMlcInit_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_riCddMlcDeInit_TestCase", Mt_CddMlc_riCddMlcDeInit_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlc_EvaluateCoding_TestCase", Mt_CddMlc_CddMlc_EvaluateCoding_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase", Mt_CddMlc_CddMlcGen_GetCodingParam_TestCase); ALUnitTest_AddFunction("Mt_CddMlc_rpCddMlc1ms_TestCase", Mt_CddMlc_rpCddMlc1ms_TestCase); }