//*****************************************************************************
// (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 software component module SysVolt
///
/// \author wpf
///         mailTo:
//-----------------------------------------------------------------------------
#include <ALUnitTest_UserInterface.h>
#include <stdio.h>
#include <AL_Helper.h>
#include <Rte_Type.h>
#include <Rte.h>
#include "Rte_ctasSysVolt.h"
#include <Crc.h>
#include <Std_Types.h>
#include "Swc/CodM/CodingTypes/Rom_Para.h"
#include <Swc/CodM/Api/CodM.h>
#include "Swc/SysVolt/SysVoltPrjCfg.h"
#include "Swc/SysVolt/SysVolt.h"

typedef struct
{
  tieSysVoltGrade    eVoltageRangeResult;
  tieSysVoltGrade    ePreviousVoltageRange;
  uint16             unDebounceCnt;
}tSysV_ResultSet;


extern tSysV_ConfigsSet SysV_Configs[NumOfSysVoltModules];
extern tSysV_ResultSet SysV_Results[NumOfSysVoltModules];
extern uint8 ucInitStatus;
extern tisCodingStatus eCodingDataStatus;
extern CONST_AL  tRomPara_Profiles  *SysVoltCfgProfile_Point;

tRomPara_SysVoltConfigBlock    SysVoltConfigData;
tisSysVolt_Result  Voltget_Value;
tisSysVolt_Result* SysVoltResult_Get_voltget = &Voltget_Value;
tieSysVoltGrade SysVolt_Cycle10ms_VoltageGrade[NumOfSysVoltModules];

uint8 SysVoltResult_Get_RetVal = 0;
uint8 SysVolt_Init_CodingStatus = 0;
uint8 SysVoltResult_Get_RetQty = 0;

uint16 SysVolt_Cycle10ms_Voltage[NumOfSysVoltModules] = {0};

FUNC(Std_ReturnType, ctahIoHwAbUser_CODE) PpasvIoHwAbUserVoltage_Get(tieIoHwAbUser_Adc_ChannelType index, P2VAR(uint16, AUTOMATIC, RTE_CTAHIOHWABUSER_APPL_VAR) VolData) 
{
  uint8 Return;

  for (uint8 i = 0; i < NumOfSysVoltModules; i++)
  {
    *VolData = SysVolt_Cycle10ms_Voltage[i];
  }
  Return = SysVoltResult_Get_RetQty;
  return Return;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctasSysVolt_PpareCodMCodingStatus_sCodingStatus(P2VAR(tisCodingStatus, AUTOMATIC, RTE_CTASSYSVOLT_APPL_VAR) data) 
{
  data->eCodingStatus = SysVolt_Init_CodingStatus;
  return RTE_E_OK;
}

STATIC_AL void Mt_Initialisation(void)
{
  uint8 Indx = 0;

  //For Rls4.0    //KL30
  SysVoltConfigData.Profiles[0].Better_Debounce_ms           = SYSV_DEFAULT_DEBTIME_DIR_BETTER_MS;
  SysVoltConfigData.Profiles[0].Worse_Debounce_ms            = SYSV_DEFAULT_DEBTIME_KL30_DIR_WORSE_MS;
  SysVoltConfigData.Profiles[0].InputChanel                  = 0u;
  SysVoltConfigData.Profiles[0].Plausible_LowThreshold       = 0u;
  SysVoltConfigData.Profiles[0].Plausible_UpThreshold        = 0u;
  SysVoltConfigData.Profiles[0].ProfileId                    = 0u;
                                                             
  //For Rls4.0    //KL15                                     
  SysVoltConfigData.Profiles[1].Better_Debounce_ms           = SYSV_DEFAULT_DEBTIME_DIR_BETTER_MS;
  SysVoltConfigData.Profiles[1].Worse_Debounce_ms            = SYSV_DEFAULT_DEBTIME_DIR_WORSE_MS;
  SysVoltConfigData.Profiles[1].InputChanel                  = 0u;
  SysVoltConfigData.Profiles[1].Plausible_LowThreshold       = 0u;
  SysVoltConfigData.Profiles[1].Plausible_UpThreshold        = 0u;
  SysVoltConfigData.Profiles[1].ProfileId                    = 1u;

  //For Rls4.0    //SBC_3V3                                     
  SysVoltConfigData.Profiles[2].Better_Debounce_ms           = SYSV_DEFAULT_DEBTIME_DIR_BETTER_MS;
  SysVoltConfigData.Profiles[2].Worse_Debounce_ms            = SYSV_DEFAULT_DEBTIME_DIR_WORSE_MS;
  SysVoltConfigData.Profiles[2].InputChanel                  = 0u;
  SysVoltConfigData.Profiles[2].Plausible_LowThreshold       = 0u;
  SysVoltConfigData.Profiles[2].Plausible_UpThreshold        = 0u;
  SysVoltConfigData.Profiles[2].ProfileId                    = 2u;

  //For Rls4.0    //DC5V                                     
  SysVoltConfigData.Profiles[3].Better_Debounce_ms           = SYSV_DEFAULT_DEBTIME_DIR_BETTER_MS;
  SysVoltConfigData.Profiles[3].Worse_Debounce_ms            = SYSV_DEFAULT_DEBTIME_DIR_WORSE_MS;
  SysVoltConfigData.Profiles[3].InputChanel                  = 0u;
  SysVoltConfigData.Profiles[3].Plausible_LowThreshold       = 0u;
  SysVoltConfigData.Profiles[3].Plausible_UpThreshold        = 0u;
  SysVoltConfigData.Profiles[3].ProfileId                    = 3u;

  //For Rls4.0    //MCU_1V25                                     
  SysVoltConfigData.Profiles[4].Better_Debounce_ms           = SYSV_DEFAULT_DEBTIME_DIR_BETTER_MS;
  SysVoltConfigData.Profiles[4].Worse_Debounce_ms            = SYSV_DEFAULT_DEBTIME_DIR_WORSE_MS;
  SysVoltConfigData.Profiles[4].InputChanel                  = 0u;
  SysVoltConfigData.Profiles[4].Plausible_LowThreshold       = 0u;
  SysVoltConfigData.Profiles[4].Plausible_UpThreshold        = 0u;
  SysVoltConfigData.Profiles[4].ProfileId                    = 4u;

  //For Rls4.0    //SBC_5V                                     
  SysVoltConfigData.Profiles[5].Better_Debounce_ms           = SYSV_DEFAULT_DEBTIME_DIR_BETTER_MS;
  SysVoltConfigData.Profiles[5].Worse_Debounce_ms            = SYSV_DEFAULT_DEBTIME_DIR_WORSE_MS;
  SysVoltConfigData.Profiles[5].InputChanel                  = 0u;
  SysVoltConfigData.Profiles[5].Plausible_LowThreshold       = 0u;
  SysVoltConfigData.Profiles[5].Plausible_UpThreshold        = 0u;
  SysVoltConfigData.Profiles[5].ProfileId                    = 5u;

  //For Rls4.0    //LEDSupply                                     
  SysVoltConfigData.Profiles[6].Better_Debounce_ms           = SYSV_DEFAULT_DEBTIME_DIR_BETTER_MS;
  SysVoltConfigData.Profiles[6].Worse_Debounce_ms            = SYSV_DEFAULT_DEBTIME_DIR_WORSE_MS;
  SysVoltConfigData.Profiles[6].InputChanel                  = 0u;
  SysVoltConfigData.Profiles[6].Plausible_LowThreshold       = 0u;
  SysVoltConfigData.Profiles[6].Plausible_UpThreshold        = 0u;
  SysVoltConfigData.Profiles[6].ProfileId                    = 6u;


  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    SysVoltConfigData.Profiles[0].GradeThresholds_mV[Indx] = 16500u;  //KL30
    SysVoltConfigData.Profiles[1].GradeThresholds_mV[Indx] = 15000u;  //KL15
    SysVoltConfigData.Profiles[2].GradeThresholds_mV[Indx] = 3700u;  //SBC3V3
    SysVoltConfigData.Profiles[3].GradeThresholds_mV[Indx] = 4500u;  //DC5V
    SysVoltConfigData.Profiles[4].GradeThresholds_mV[Indx] = 1400u;  //MCU1V25
    SysVoltConfigData.Profiles[5].GradeThresholds_mV[Indx] = 5500u;  //SBC5V
    SysVoltConfigData.Profiles[6].GradeThresholds_mV[Indx] = 16500u; //LEDSupply
  }

  SysVoltCfgProfile_Point = &(SysVoltConfigData.Profiles[0]);
  
  SysV_Configs[0].pRangeCfg[0].unVoltRangeUpperLimit_mV = 6000;
  SysV_Configs[0].pRangeCfg[1].unVoltRangeUpperLimit_mV = 8500;
  SysV_Configs[0].pRangeCfg[2].unVoltRangeUpperLimit_mV = 9500;
  SysV_Configs[0].pRangeCfg[3].unVoltRangeUpperLimit_mV = 16500;
  SysV_Configs[0].pRangeCfg[4].unVoltRangeUpperLimit_mV = 20000;
  SysV_Configs[0].pRangeCfg[5].unVoltRangeUpperLimit_mV = SYSV_LIST_TERM;
  SysV_Configs[0].pRangeCfg[6].unVoltRangeUpperLimit_mV = 0;

  SysV_Configs[1].pRangeCfg[0].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[1].pRangeCfg[1].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[1].pRangeCfg[2].unVoltRangeUpperLimit_mV = 2800;
  SysV_Configs[1].pRangeCfg[3].unVoltRangeUpperLimit_mV = 3700;
  SysV_Configs[1].pRangeCfg[4].unVoltRangeUpperLimit_mV = SYSV_LIST_TERM;
  SysV_Configs[1].pRangeCfg[5].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[1].pRangeCfg[6].unVoltRangeUpperLimit_mV = 0;

  SysV_Configs[2].pRangeCfg[0].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[2].pRangeCfg[1].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[2].pRangeCfg[2].unVoltRangeUpperLimit_mV = 4500;
  SysV_Configs[2].pRangeCfg[3].unVoltRangeUpperLimit_mV = 5500;
  SysV_Configs[2].pRangeCfg[4].unVoltRangeUpperLimit_mV = SYSV_LIST_TERM;
  SysV_Configs[2].pRangeCfg[5].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[2].pRangeCfg[6].unVoltRangeUpperLimit_mV = 0;

  SysV_Configs[3].pRangeCfg[0].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[3].pRangeCfg[1].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[3].pRangeCfg[2].unVoltRangeUpperLimit_mV = 1000;
  SysV_Configs[3].pRangeCfg[3].unVoltRangeUpperLimit_mV = 1400;
  SysV_Configs[3].pRangeCfg[4].unVoltRangeUpperLimit_mV = SYSV_LIST_TERM;
  SysV_Configs[3].pRangeCfg[5].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[3].pRangeCfg[6].unVoltRangeUpperLimit_mV = 0;

  SysV_Configs[4].pRangeCfg[0].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[4].pRangeCfg[1].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[4].pRangeCfg[2].unVoltRangeUpperLimit_mV = 4500;
  SysV_Configs[4].pRangeCfg[3].unVoltRangeUpperLimit_mV = 5500;
  SysV_Configs[4].pRangeCfg[4].unVoltRangeUpperLimit_mV = SYSV_LIST_TERM;
  SysV_Configs[4].pRangeCfg[5].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[4].pRangeCfg[6].unVoltRangeUpperLimit_mV = 0;

  SysV_Configs[5].pRangeCfg[0].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[5].pRangeCfg[1].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[5].pRangeCfg[2].unVoltRangeUpperLimit_mV = 3800;
  SysV_Configs[5].pRangeCfg[3].unVoltRangeUpperLimit_mV = 18000;
  SysV_Configs[5].pRangeCfg[4].unVoltRangeUpperLimit_mV = SYSV_LIST_TERM;
  SysV_Configs[5].pRangeCfg[5].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[5].pRangeCfg[6].unVoltRangeUpperLimit_mV = 0;

  SysV_Configs[6].pRangeCfg[0].unVoltRangeUpperLimit_mV = 0;
  SysV_Configs[6].pRangeCfg[1].unVoltRangeUpperLimit_mV = 8500;
  SysV_Configs[6].pRangeCfg[2].unVoltRangeUpperLimit_mV = 9500;
  SysV_Configs[6].pRangeCfg[3].unVoltRangeUpperLimit_mV = 19000;
  SysV_Configs[6].pRangeCfg[4].unVoltRangeUpperLimit_mV = 20000;
  SysV_Configs[6].pRangeCfg[5].unVoltRangeUpperLimit_mV = SYSV_LIST_TERM;
  SysV_Configs[6].pRangeCfg[6].unVoltRangeUpperLimit_mV = 0;

}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SysVolt_UpdateCoding
///
/// \Test Case Description
///    - Test subject:
///        Check whether the function call to update the Coding data is correct
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: Set the Coding data
///
///    - Expected test results:
///        - All conditions and assigned values  need to be reached and passed.
///
//-----------------------------------------------------------------------------
void Mt_SysVolt_UpdateCoding(void)
{
  uint8 Indx = 0;

  Mt_Initialisation();
  SysVolt_UpdateCoding();
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_3V3].unDebounceCnt_RangeGetsBetter, 10, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_3V3].unDebounceCnt_RangeGetsWorse, 40, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_DCDC_5V].unDebounceCnt_RangeGetsBetter, 10, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_DCDC_5V].unDebounceCnt_RangeGetsWorse, 40, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_MCU_1V25].unDebounceCnt_RangeGetsBetter, 10, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_MCU_1V25].unDebounceCnt_RangeGetsWorse, 40, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_5V].unDebounceCnt_RangeGetsBetter, 10, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_5V].unDebounceCnt_RangeGetsWorse, 40, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL15].unDebounceCnt_RangeGetsBetter, 10, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL15].unDebounceCnt_RangeGetsWorse, 40, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_LEDSupply].unDebounceCnt_RangeGetsBetter, 10, == );
  AL_UNITTEST_CHECK(SysV_Configs[PROFILE_LEDSupply].unDebounceCnt_RangeGetsWorse, 40, == );

  for (Indx  = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL30].pRangeCfg[Indx].unVoltRangeUpperLimit_mV,16500, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_3V3].pRangeCfg[Indx].unVoltRangeUpperLimit_mV,3700, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_DCDC_5V].pRangeCfg[Indx].unVoltRangeUpperLimit_mV,4500, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_MCU_1V25].pRangeCfg[Indx].unVoltRangeUpperLimit_mV,1400, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_5V].pRangeCfg[Indx].unVoltRangeUpperLimit_mV,5500, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL15].pRangeCfg[Indx].unVoltRangeUpperLimit_mV,15000, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_LEDSupply].pRangeCfg[Indx].unVoltRangeUpperLimit_mV,16500, == );
  }



  //For Rls4.0 
  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL30].Channelidx, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL30].Plausible_UpThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL30].Plausible_LowThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL30].ProfileId, 0, == );

    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL15].Channelidx, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL15].Plausible_UpThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL15].Plausible_LowThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_KL15].ProfileId, 1, == );

    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_3V3].Channelidx, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_3V3].Plausible_UpThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_3V3].Plausible_LowThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_3V3].ProfileId, 2, == );

    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_DCDC_5V].Channelidx, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_DCDC_5V].Plausible_UpThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_DCDC_5V].Plausible_LowThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_DCDC_5V].ProfileId, 3, == );

    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_MCU_1V25].Channelidx, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_MCU_1V25].Plausible_UpThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_MCU_1V25].Plausible_LowThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_MCU_1V25].ProfileId, 4, == );

    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_5V].Channelidx, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_5V].Plausible_UpThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_5V].Plausible_LowThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_SBC_5V].ProfileId, 5, == );

    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_LEDSupply].Channelidx, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_LEDSupply].Plausible_UpThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_LEDSupply].Plausible_LowThreshold, 0, == );
    AL_UNITTEST_CHECK(SysV_Configs[PROFILE_LEDSupply].ProfileId, 6, == );

  }
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SysVoltResult_Get
///
/// \Test Case Description
///    - Test subject:
///        Check the return value of the function by setting its input parameters
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: Set the input parameters
///
///    - Expected test results:
///        - All conditions and assigned values  need to be reached and passed.
///
//-----------------------------------------------------------------------------
void Mt_SysVoltResult_Get(void)
{
	SysVoltResult_Get_RetVal = SysVoltResult_Get(PROFILE_KL30, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_OK, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(PROFILE_KL15, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_OK, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(PROFILE_LEDSupply, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_OK, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(NumOfSysVoltModules, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_OUT_OF_RANGE, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(NumOfSysVoltModules + 1, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_OUT_OF_RANGE, == );
	SysVoltResult_Get_voltget = (tisSysVolt_Result *)NULL_PTR;
	SysVoltResult_Get_RetVal = SysVoltResult_Get(PROFILE_KL30, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_INVALID, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(PROFILE_KL15, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_INVALID, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(PROFILE_LEDSupply, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_INVALID, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(NumOfSysVoltModules, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_OUT_OF_RANGE, == );
	SysVoltResult_Get_RetVal = SysVoltResult_Get(NumOfSysVoltModules + 1, SysVoltResult_Get_voltget);
	AL_UNITTEST_CHECK(SysVoltResult_Get_RetVal, RTE_E_OUT_OF_RANGE, == );

}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SysVolt_Read_Voltage
///
/// \Test Case Description
///    - Test subject:
///        Check whether the function call to obtain the voltage is correct
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: Set the input parameters
///
///    - Expected test results:
///        - All conditions and assigned values  need to be reached and passed.
///
//-----------------------------------------------------------------------------
void Mt_SysVolt_Read_Voltage(void)
{

  uint8 Indx = 0;


  SysVoltResult_Get_RetQty = 0u;
  ucInitStatus = 0;
  SysVolt_Read_Voltage();
  AL_UNITTEST_CHECK(ucInitStatus, 1u, == );

  ucInitStatus = 1;

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  SysVolt_Cycle10ms_Voltage[Indx] = 9500;
  }
  SysVolt_Read_Voltage();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  AL_UNITTEST_CHECK((SysV_Configs[Indx].RteReadVoltage), 9500, == );
  }
  AL_UNITTEST_CHECK(SysV_Configs[Indx].SysVoltQty, 0u, == );



  SysVoltResult_Get_RetQty = 1u;
  ucInitStatus = 0;
  SysVolt_Read_Voltage();
  ucInitStatus = 1;

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    SysVolt_Cycle10ms_Voltage[Indx] = 9500;
  }
  SysVolt_Read_Voltage();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    AL_UNITTEST_CHECK((SysV_Configs[Indx].RteReadVoltage), 9500, == );
  }
  AL_UNITTEST_CHECK(SysV_Configs[Indx].SysVoltQty, 0u, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SysVolt_State
///
/// \Test Case Description
///    - Test subject:
///        Check whether the function call to get the voltage status is correct
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: Set the input parameters
///
///    - Expected test results:
///        - All conditions and assigned values  need to be reached and passed.
///
//-----------------------------------------------------------------------------
void Mt_SysVolt_State(void)
{
  SysVolt_State(PROFILE_KL30, SysVolt_eNormal);
  AL_UNITTEST_CHECK((SysV_Configs[PROFILE_KL30].RteWritevoltstatus), SysVolt_eNormal, == );

  SysVolt_State(PROFILE_SBC_3V3, SysVolt_eNormal);
  AL_UNITTEST_CHECK((SysV_Configs[PROFILE_SBC_3V3].RteWritevoltstatus), SysVolt_eNormal, == );

  SysVolt_State(PROFILE_DCDC_5V, SysVolt_eNormal);
  AL_UNITTEST_CHECK((SysV_Configs[PROFILE_DCDC_5V].RteWritevoltstatus), SysVolt_eNormal, == );

  SysVolt_State(PROFILE_MCU_1V25, SysVolt_eNormal);
  AL_UNITTEST_CHECK((SysV_Configs[PROFILE_MCU_1V25].RteWritevoltstatus), SysVolt_eNormal, == );

  SysVolt_State(PROFILE_SBC_5V, SysVolt_eNormal);
  AL_UNITTEST_CHECK((SysV_Configs[PROFILE_SBC_5V].RteWritevoltstatus), SysVolt_eNormal, == );

  SysVolt_State(PROFILE_KL15, SysVolt_eNormal);
  AL_UNITTEST_CHECK((SysV_Configs[PROFILE_KL15].RteWritevoltstatus), SysVolt_eNormal, == );

  SysVolt_State(PROFILE_LEDSupply, SysVolt_eNormal);
  AL_UNITTEST_CHECK((SysV_Configs[PROFILE_LEDSupply].RteWritevoltstatus), SysVolt_eNormal, == );

}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SysVolt_Init
///
/// \Test Case Description
///    - Test subject:
///        Check that the initialization function call is correct
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: Set the validation status of Coding
///
///    - Expected test results:
///        - All conditions and assigned values  need to be reached and passed.
///
//-----------------------------------------------------------------------------
void Mt_SysVolt_Init(void)
{
  uint8 Indx;
  uint8 i;
  ucInitStatus = 1;
  SysVolt_Init_CodingStatus = CODING_STATUS_VALID;
  for (i = 0; i < 7; i++)
  {
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[0] = 100;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[1] = 200;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[2] = 300;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[3] = 400;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[4] = 500;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[5] = 600;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[6] = 700;
  }
  SysVolt_Cycle10ms_Voltage[0] = 210;
  SysVolt_Cycle10ms_Voltage[1] = 210;
  SysVolt_Cycle10ms_Voltage[2] = 210;
  SysVolt_Cycle10ms_Voltage[3] = 210;
  SysVolt_Cycle10ms_Voltage[4] = 210;
  SysVolt_Cycle10ms_Voltage[5] = 210;
  SysVolt_Cycle10ms_Voltage[6] = 210;
  SysVoltCfgProfile_Point = &(SysVoltConfigData.Profiles[0]);
  SysVolt_Init();

  AL_UNITTEST_CHECK(eCodingDataStatus.eCodingStatus, CODING_STATUS_VALID, == );
  for (Indx = 0; Indx < 7; Indx++)
  {
    AL_UNITTEST_CHECK(SysV_Results[Indx].ePreviousVoltageRange, 2, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, 2, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].unDebounceCnt, SYSV_DEBOUNCE_CNT_ELAPSED, == );
  }

  SysVolt_Init_CodingStatus = CODING_STATUS_VALID;
  for (i = 0; i < 7; i++)
  {
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[0] = 100;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[1] = 200;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[2] = 300;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[3] = 400;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[4] = 500;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[5] = 600;
    SysVoltConfigData.Profiles[i].GradeThresholds_mV[6] = 700;
  }
  SysVolt_Cycle10ms_Voltage[0] = 750;
  SysVolt_Cycle10ms_Voltage[1] = 750;
  SysVolt_Cycle10ms_Voltage[2] = 750;
  SysVolt_Cycle10ms_Voltage[3] = 750;
  SysVolt_Cycle10ms_Voltage[4] = 750;
  SysVolt_Cycle10ms_Voltage[5] = 750;
  SysVolt_Cycle10ms_Voltage[6] = 750;
  SysVoltCfgProfile_Point = &(SysVoltConfigData.Profiles[0]);
  SysVolt_Init();

  AL_UNITTEST_CHECK(eCodingDataStatus.eCodingStatus, CODING_STATUS_VALID, == );
  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    AL_UNITTEST_CHECK(SysV_Results[Indx].ePreviousVoltageRange, 6, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, 6, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].unDebounceCnt, SYSV_DEBOUNCE_CNT_ELAPSED, == );
  }

  SysVolt_Init_CodingStatus = CODING_STATUS_CRCCHECKERR;
  for (i = 0; i < 7; i++)
  {
    SysV_Configs[i].pRangeCfg[0].unVoltRangeUpperLimit_mV = 100;
    SysV_Configs[i].pRangeCfg[1].unVoltRangeUpperLimit_mV = 200;
    SysV_Configs[i].pRangeCfg[2].unVoltRangeUpperLimit_mV = 300;
    SysV_Configs[i].pRangeCfg[3].unVoltRangeUpperLimit_mV = 400;
    SysV_Configs[i].pRangeCfg[4].unVoltRangeUpperLimit_mV = 500;
    SysV_Configs[i].pRangeCfg[5].unVoltRangeUpperLimit_mV = 600;
    SysV_Configs[i].pRangeCfg[6].unVoltRangeUpperLimit_mV = 700;
  }
  SysVolt_Cycle10ms_Voltage[0] = 150;
  SysVolt_Cycle10ms_Voltage[1] = 150;
  SysVolt_Cycle10ms_Voltage[2] = 150;
  SysVolt_Cycle10ms_Voltage[3] = 150;
  SysVolt_Cycle10ms_Voltage[4] = 150;
  SysVolt_Cycle10ms_Voltage[5] = 150;
  SysVolt_Cycle10ms_Voltage[6] = 150;

  SysVolt_Init();

  AL_UNITTEST_CHECK(eCodingDataStatus.eCodingStatus, CODING_STATUS_CRCCHECKERR, == );
  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	AL_UNITTEST_CHECK(SysV_Results[Indx].ePreviousVoltageRange, 1, == );
	AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, 1, == );
	AL_UNITTEST_CHECK(SysV_Results[Indx].unDebounceCnt, SYSV_DEBOUNCE_CNT_ELAPSED, == );
  }

  SysVolt_Init_CodingStatus = CODING_STATUS_CRCCHECKERR;
  for (i = 0; i < 7; i++)
  {
    SysV_Configs[i].pRangeCfg[0].unVoltRangeUpperLimit_mV = 100;
    SysV_Configs[i].pRangeCfg[1].unVoltRangeUpperLimit_mV = 200;
    SysV_Configs[i].pRangeCfg[2].unVoltRangeUpperLimit_mV = 300;
    SysV_Configs[i].pRangeCfg[3].unVoltRangeUpperLimit_mV = 400;
    SysV_Configs[i].pRangeCfg[4].unVoltRangeUpperLimit_mV = 500;
    SysV_Configs[i].pRangeCfg[5].unVoltRangeUpperLimit_mV = 600;
    SysV_Configs[i].pRangeCfg[6].unVoltRangeUpperLimit_mV = 700;
  }
  SysVolt_Cycle10ms_Voltage[0] = 750;
  SysVolt_Cycle10ms_Voltage[1] = 750;
  SysVolt_Cycle10ms_Voltage[2] = 750;
  SysVolt_Cycle10ms_Voltage[3] = 750;
  SysVolt_Cycle10ms_Voltage[4] = 750;
  SysVolt_Cycle10ms_Voltage[5] = 750;
  SysVolt_Cycle10ms_Voltage[6] = 750;

  SysVolt_Init();

  AL_UNITTEST_CHECK(eCodingDataStatus.eCodingStatus, CODING_STATUS_CRCCHECKERR, == );
  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    AL_UNITTEST_CHECK(SysV_Results[Indx].ePreviousVoltageRange, 6, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, 6, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].unDebounceCnt, SYSV_DEBOUNCE_CNT_ELAPSED, == );
  }

  SysVolt_Init_CodingStatus = CODING_STATUS_CRCCHECKERR;
  for (i = 0; i < 7; i++)
  {
    SysV_Configs[i].pRangeCfg[0].unVoltRangeUpperLimit_mV = 100;
    SysV_Configs[i].pRangeCfg[1].unVoltRangeUpperLimit_mV = 200;
    SysV_Configs[i].pRangeCfg[2].unVoltRangeUpperLimit_mV = 300;
    SysV_Configs[i].pRangeCfg[3].unVoltRangeUpperLimit_mV = 400;
    SysV_Configs[i].pRangeCfg[4].unVoltRangeUpperLimit_mV = 500;
    SysV_Configs[i].pRangeCfg[5].unVoltRangeUpperLimit_mV = 600;
    SysV_Configs[i].pRangeCfg[6].unVoltRangeUpperLimit_mV = 700;
  }
  SysVolt_Cycle10ms_Voltage[0] = 50;
  SysVolt_Cycle10ms_Voltage[1] = 50;
  SysVolt_Cycle10ms_Voltage[2] = 50;
  SysVolt_Cycle10ms_Voltage[3] = 50;
  SysVolt_Cycle10ms_Voltage[4] = 50;
  SysVolt_Cycle10ms_Voltage[5] = 50;
  SysVolt_Cycle10ms_Voltage[6] = 50;

  SysVolt_Init();

  AL_UNITTEST_CHECK(eCodingDataStatus.eCodingStatus, CODING_STATUS_CRCCHECKERR, == );
  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    AL_UNITTEST_CHECK(SysV_Results[Indx].ePreviousVoltageRange, 0, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, 0, == );
    AL_UNITTEST_CHECK(SysV_Results[Indx].unDebounceCnt, SYSV_DEBOUNCE_CNT_ELAPSED, == );
  }
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SysVolt_Cycle10ms
///
/// \Test Case Description
///    - Test subject:
///        Check whether the main loop function call is correct
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: Set voltage value, voltage level, anti-shake time.
///
///    - Expected test results:
///        - All conditions and assigned values  need to be reached and passed.
///
//-----------------------------------------------------------------------------
void Mt_SysVolt_Cycle10ms(void)
{
  uint8 Indx;
  Mt_Initialisation();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
  	SysVolt_Cycle10ms_Voltage[Indx] = 9500;
	  SysV_Results[Indx].ePreviousVoltageRange = SysVolt_eNormal;
	  SysV_Results[Indx].unDebounceCnt = 10;

	for (uint8 i = 0; i < NumOfSysVoltModules; i++)
	{
		SysV_Configs[Indx].pRangeCfg[i].VoltRangeName = SysVolt_eNormal;
	}
  }

  SysVolt_Cycle10ms();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, SysVolt_eLow3, == );
	  AL_UNITTEST_CHECK((SysV_Configs[Indx].RteReadVoltage), 9500, == );
  }
  


  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    SysVolt_Cycle10ms_Voltage[Indx] = 10000;
    SysV_Results[Indx].ePreviousVoltageRange = SysVolt_eLow1;
    SysV_Results[Indx].unDebounceCnt = 0;

	for (uint8 i = 0; i < NumOfSysVoltModules; i++)
	{
      SysV_Configs[Indx].pRangeCfg[i].VoltRangeName = SysVolt_eNormal;
	}
  }
  SysVolt_Cycle10ms();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  //AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, SysVolt_eLow3, == );
	  AL_UNITTEST_CHECK((SysV_Configs[Indx].RteReadVoltage), 10000, == );
  }


  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
    SysVolt_Cycle10ms_Voltage[Indx] = 9000;
    SysV_Results[Indx].ePreviousVoltageRange = SysVolt_eHigh1;
    SysV_Results[Indx].unDebounceCnt = 10;
    SysV_Configs[Indx].RteWritevoltstatus = SysVolt_Cycle10ms_VoltageGrade[Indx];
    
    for (uint8 i = 0; i < NumOfSysVoltModules; i++)
    {
      SysV_Configs[Indx].pRangeCfg[i].VoltRangeName = SysVolt_eNormal;
    }  
  }
  SysVolt_Cycle10ms();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  //AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, SysVolt_eLow3, == );
	  AL_UNITTEST_CHECK((SysV_Configs[Indx].RteReadVoltage), 9000, == );
  }



  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  SysVolt_Cycle10ms_Voltage[Indx] = 18000;
	  SysV_Results[Indx].ePreviousVoltageRange = SysVolt_eNormal;
	  SysV_Results[Indx].unDebounceCnt = 10;
	  SysV_Configs[Indx].RteWritevoltstatus = SysVolt_Cycle10ms_VoltageGrade[Indx];

	for (uint8 i = 0; i < NumOfSysVoltModules; i++)
	{
	  SysV_Configs[Indx].pRangeCfg[i].VoltRangeName = SysVolt_eHigh1;
	}
  }
  SysVolt_Cycle10ms();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  //AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, SysVolt_eLow3, == );
	  AL_UNITTEST_CHECK((SysV_Configs[Indx].RteReadVoltage), 18000, == );
  }


  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  SysVolt_Cycle10ms_Voltage[Indx] = 18000;
	  SysV_Results[Indx].ePreviousVoltageRange = SysVolt_eLow1;
	  SysV_Results[Indx].unDebounceCnt = 0;
	  SysV_Results[Indx].eVoltageRangeResult = SysVolt_eNormal;
	  SysV_Configs[Indx].RteWritevoltstatus = SysVolt_Cycle10ms_VoltageGrade[Indx];
    
	for (uint8 i = 0; i < NumOfSysVoltModules; i++)
	{
	  SysV_Configs[Indx].pRangeCfg[i].VoltRangeName = SysVolt_eLow1;
	}
  }
  SysVolt_Cycle10ms();

  for (Indx = 0; Indx < NumOfSysVoltModules; Indx++)
  {
	  AL_UNITTEST_CHECK(SysV_Results[Indx].eVoltageRangeResult, SysVolt_eLow1, == );
	  AL_UNITTEST_CHECK((SysV_Configs[Indx].RteReadVoltage), 18000, == );
  }

}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_Rte_riSysVoltInit
///
/// \Test Case Description
///    - Test subject:
///        Call the RTE runnable riSysVoltInit().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_Rte_riSysVoltInit(void)
{
  Rte_riSysVoltInit();
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_Rte_rpSysVolt10ms
///
/// \Test Case Description
///    - Test subject:
///        Call the RTE runnable rpSysVolt10ms().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_Rte_rpSysVolt10ms(void)
{
  Rte_rpSysVolt10ms();
}



void ALUnitTest_AddTests(void)
{
  ALUnitTest_AddFunction("Mt_SysVolt_UpdateCoding", Mt_SysVolt_UpdateCoding);
  ALUnitTest_AddFunction("Mt_SysVoltResult_Get", Mt_SysVoltResult_Get);
  ALUnitTest_AddFunction("Mt_SysVolt_Init", Mt_SysVolt_Init);
  ALUnitTest_AddFunction("Mt_SysVolt_Cycle10ms", Mt_SysVolt_Cycle10ms);
  ALUnitTest_AddFunction("Mt_SysVolt_State", Mt_SysVolt_State);
  ALUnitTest_AddFunction("Mt_SysVolt_Read_Voltage", Mt_SysVolt_Read_Voltage);
  ALUnitTest_AddFunction("Mt_Rte_riSysVoltInit", Mt_Rte_riSysVoltInit);
  ALUnitTest_AddFunction("Mt_Rte_rpSysVolt10ms", Mt_Rte_rpSysVolt10ms);

}