//*****************************************************************************
// (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 SigPrep1
///
/// \author 
///         
//-----------------------------------------------------------------------------

#include <ALUnitTest_UserInterface.h>
#include <stdio.h>
#include <AL_Helper.h>
#include <Rte_Type.h>
#include <Rte.h>
#include <Std_Types.h>
#include "SigPrep1/SigPrep1Rx.h"
#include "SigPrep1/SigPrep1.h"
#include "Rte_ctaaSigPrep1.h"
#include "SigPrep1/Msg/SigPrep1_MsgHLMLStatesInfo.h"
#include "SigPrep1/Msg/SigPrep1_MsgHLMRStatesInfo.h"
#include "SigPrep1/Msg/SigPrep1_MsgAFSCommandTx.h"
#include "SigPrep1/Msg/SigPrep1_MsgLightControlCommandTx.h"
#include "SigPrep1/Msg/SigPrep1_MsgMatrixHBCommandTx.h"
#include "SigPrep1/Msg/SigPrep1_MsgVehicleInfoTx.h"
#include "SigPrep1/Msg/SigPrep1_MsgCeremonyCmdLeft1Tx.h"
#include "SigPrep1/Msg/SigPrep1_MsgCeremonyCmdRight1Tx.h"
#include "SigPrep1/Msg/SigPrep1_MsgCeremonyCmdLeft2Tx.h"
#include "SigPrep1/Msg/SigPrep1_MsgCeremonyCmdRight2Tx.h"
#include "SigPrep1/SigPrep1_Common.h"
/*
typedef struct
{
  tisCommDiagInfo sHlmLStatesInfo;
  tisCommDiagInfo sHlmRStatesInfo;
} tisSubCanDiagInfo;
*/
/* SigPrep1.c*/
tisSubCanDiagInfo sSubCanDiagInfo;

tSigPrep1CounterMonitor CounterMonitor;
/* SigPrep1_Common.c*/
uint32 SigPrep1_divAndRoundClosest_result = 0;
uint32 dividend = 0;
uint32 divisor = 0;
tSigPrep1Signal_Val Sig;
tSigPrep1Signal_usVal usSig;
tSigPrep1SignalQuality quality;
tSigPrep1CounterMonitor monitor;
tSigPrep1CounterMonitor* pCntMon;
uint8 retVal = 3;
uint16 valInvalid = FALSE;
boolean value = 0;
uint8 buff[10];
uint16 size = 10;
uint8 value2 = 0;


/*SigPrep1Rx.c */

/*
typedef struct
{
  uint8       cntActivate;     ///< Count of problems or invalid values until Failure / DTC or state set to fail
  uint8       cntDeActivate;   ///< Count of successful received CAN PDUs until clear Failure / DTC
  uint8       cnt;             ///< current problem counter in a row
  boolean     isDebounced;     ///< Failure or DTC active
  boolean     isActiveDtc;     ///< flag to remember whether monitor based DTC has been set.
} tSigPrep1CounterMonitor;        ///< Counter because indications can be counted.

typedef struct
{
  uint32      toutActivate;       ///< Initial timer value in milliseconds until DTC when CAN PDU is not received
  uint32      toutDeActivate;     ///< Initial timer value in milliseconds until DTC can be cleared when CAN PDU is received again
  boolean     isTimeout;          ///< DTC active
  boolean     isActiveDtc;        ///< flag to remember whether monitor based DTC has been set.
} tSigPrep1TimerMonitor; //-- NOTE: Currently SigPrep does not use own timers. Instead Rte is expected to deliver timeout info.

typedef struct
{
  SigPrep1_EnumCanPduState state; //-- all errors result in one state
  tSigPrep1PduMonitorE2E   monitor;
  uint32 dummy;
} tSigPrep1PduQualityE2E;

typedef struct
{
  SigPrep1_EnumSignalState state;
  tSigPrep1CounterMonitor  monitor;
} tSigPrep1SignalQuality;

typedef enum SigPrep1_EnumSignalState
{
  eSigPrep1SigState_Init = 0,
  eSigPrep1SigState_Valid = 1,  ///< The signal value does not indicate problems.
  eSigPrep1SigState_PreInvalid, ///< The signal value is invalid, but not enough times to consider the signal as invalid.
  eSigPrep1SigState_Invalid,    ///< The signal value was constantly erroneous for a period of time.
  eSigPrep1SigState_Last
} SigPrep1_EnumSignalState;

typedef enum SigPrep1_EnumErrorIndicationType
{
  eSigPrep1ErrNone = 0,               ///< RTE stack indicates that CAN PDU has been received successfully      
  eSigPrep1ErrIndRteAliveCounter,     ///< RTE stack indicates ALIVE COUNTER error (for E2E protected CAN PDUs only)
  eSigPrep1ErrIndRteCrc,              ///< RTE stack indicates CRC error (for E2E protected CAN PDUs only)
  eSigPrep1ErrIndRteTimeout,          ///< RTE stack indicates Timeout error (CAN PDU not received in cyclic time)
  eSigPrep1ErrIndSelfTimeout          ///< SigPrep's own timer indicates TIMEOUT error (currently not in use)
} SigPrep1_EnumErrorIndicationType;

typedef struct
{
  tSigPrep1PduMonitorGroup   monitorAliveCounter;   //-- ALIVE COUNTER
  tSigPrep1PduMonitorGroup   monitorCrc;            //-- CRC
  tSigPrep1PduMonitorGroup   monitorRteTimeout;     //-- TIMEOUT by RTE error indication
  tSigPrep1TimerMonitor      monitorSelfTimer;      //-- TIMEOUT by SigPreps own timer (independent of RTE CAN PDU reception / error indication)
} tSigPrep1PduMonitorE2E;

typedef struct
{
  tSigPrep1CounterMonitor monitorFail; //-- monitor for CAN PDU state or signal state
  tSigPrep1CounterMonitor monitorDTC; //-- monitor for DTC
} tSigPrep1PduMonitorGroup;
*/
//typedef enum
//{
//    E2E_P02STATUS_OK            = 0x00u,
//    E2E_P02STATUS_NONEWDATA     = 0x01u,
//    E2E_P02STATUS_WRONGCRC      = 0x02u,
//    E2E_P02STATUS_SYNC          = 0x03u,
//    E2E_P02STATUS_INITIAL       = 0x04u, 
//    E2E_P02STATUS_REPEATED      = 0x08u,
//    E2E_P02STATUS_OKSOMELOST    = 0x20u,
//    E2E_P02STATUS_WRONGSEQUENCE = 0x40u
//} E2E_P02CheckStatusType;


uint32 nLimitActivate  = 1;
uint32 nLimitDeActivate = 1;

tSigPrep1TimerMonitor TimerMonitor;
uint32 nToutActivateMsec = 1;
uint32 nToutDeActivateMsec = 2;

tSigPrep1PduQualityE2E PduQualityE2E;

tSigPrep1SignalQuality SignalQuality;

tSigPrep1PduMonitorGroup MonitorGroupAliveCounter;
tSigPrep1PduMonitorGroup MonitorGroupCrc;
tSigPrep1PduMonitorGroup MonitorGroupRteTimeout;
tSigPrep1PduMonitorE2E MonitorE2E;
tSigPrep1CounterMonitor CounterMonitorFail;
tSigPrep1CounterMonitor CounterMonitorDTC;

uint32 E2E_ReadReturnVal;
uint8 GetE2E_ErrorIndicationResult;

/* SigPrep1_MsgAFSCommandTx.c */
STATIC_AL SG_sigGrpAfsCommand sAFSCommand;
STATIC_AL tisClamp2Light_AFSCommand sClamp2Light_AFSCommand;
STATIC_AL tisStpMVerticalTgt sStpMVerticalTgt;

/* SigPrep1_MsgCeremonyCmdLeft1Tx.c */
STATIC_AL tisPlsR_CeremonyCmd1 sPlsR_CeremonyCmd1_0;    // left headlamp
STATIC_AL SG_sigGrpCeremonyCmdLeft1 sCeremonyCmdLeft1;

/* SigPrep1_MsgCeremonyCmdLeft2Tx.c */
STATIC_AL tisPlsR_CeremonyCmd2 sPlsR_CeremonyCmd2_0;    // left headlamp
STATIC_AL SG_sigGrpCeremonyCmdLeft2 sCeremonyCmdLeft2;

/* SigPrep1_MsgCeremonyCmdRight1Tx.c */
STATIC_AL tisPlsR_CeremonyCmd1 sPlsR_CeremonyCmd1_1;    // right headlamp
STATIC_AL SG_sigGrpCeremonyCmdRight1 sCeremonyCmdRight1;

/* SigPrep1_MsgCeremonyCmdRight2Tx.c */
STATIC_AL tisPlsR_CeremonyCmd2 sPlsR_CeremonyCmd2_1;    // right headlamp
STATIC_AL SG_sigGrpCeremonyCmdRight2 sCeremonyCmdRight2;

/* SigPrep1_MsgHLMLStatesInfo.c */
STATIC_AL SG_sigGrpHlmLeftStatesInfo sHLMLSTATESInfo;
STATIC_AL tSigPrepCanMsg_HLM_L_STATES_Info msg_HLM_L_STATES_Info;
STATIC_AL tisHlmStatesInfo_Swc sHlmStatesInfo_Swc0;

uint8 GetHLMLStatesInfoResult;
uint8 GetHLM_L_STATES_InfoResult;
uint8 PpsreComHLMLSTATESInfo_sHLMLSTATESInfo;

/* SigPrep1_MsgHLMRStatesInfo.c */
STATIC_AL SG_sigGrpHlmRightStatesInfo sHLMRSTATESInfo;
STATIC_AL tSigPrepCanMsg_HLM_R_STATES_Info msg_HLM_R_STATES_Info;
STATIC_AL tisHlmStatesInfo_Swc sHlmStatesInfo_Swc1;

uint8 GetHLMRStatesInfoResult;
uint8 GetHLM_R_STATES_InfoResult;
uint8 PpsreComHLMRSTATESInfo_sHLMRSTATESInfo;

/* SigPrep1_MsgLightControlCommandTx.c */
STATIC_AL tisClamp2Light_LightControlCommand sClamp2Light_LightControlCommand;
STATIC_AL SG_sigGrpLightControlCommand sLightControlCommand;

/* SigPrep1_MsgMatrixHBCommandTx.c */
STATIC_AL tisClamp2Light_MatrixHBCommand sClamp2Light_MatrixHBCommand;
STATIC_AL SG_sigGrpMatrixHbCommmand sMatrixHBCommand;

/* SigPrep1_MsgVehicleInfoTx.c */
STATIC_AL tisVehicleDynamic sVehicleDynamic;
STATIC_AL tisGeneralInfo sGeneralInfo;
STATIC_AL tisGlobalTime sGlobalTime;
STATIC_AL tisPlsR_VehicleInfo sPlsr_VehicleInfo;
STATIC_AL SG_sigGrpVehicleInfo sVehicleInfo;


FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctaaSigPrep1_PpaseSigPrep1HlmStatesInfo_Swc0_sHlmStatesInfo_Swc0(P2CONST(tisHlmStatesInfo_Swc, AUTOMATIC, RTE_CTAASIGPREP1_APPL_DATA) data)
{
  return RTE_E_OK;
}

FUNC(uint32, ctaaSigPrep1_CODE) E2EPW_Read_PpsreComHLMLSTATESInfo_sHLMLSTATESInfo(P2VAR(SG_sigGrpHlmLeftStatesInfo, AUTOMATIC, ctaaSigPrep1_VAR_INIT) AppData)
{
  if( PpsreComHLMLSTATESInfo_sHLMLSTATESInfo == eSigPrep1ErrNone)
  {
    return 0;
  }
  else
  {
    return 0x00008100;
  }
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctaaSigPrep1_PpaseSigPrep1HlmStatesInfo_Swc1_sHlmStatesInfo_Swc1(P2CONST(tisHlmStatesInfo_Swc, AUTOMATIC, RTE_CTAASIGPREP1_APPL_DATA) data)
{
  return RTE_E_OK;
}


FUNC(uint32, ctaaSigPrep1_CODE) E2EPW_Read_PpsreComHLMRSTATESInfo_sHLMRSTATESInfo(P2VAR(SG_sigGrpHlmRightStatesInfo, AUTOMATIC, ctaaSigPrep1_VAR_INIT) AppData)
{
  if( PpsreComHLMRSTATESInfo_sHLMRSTATESInfo == eSigPrep1ErrNone)
  {
    return 0;
  }
  else
  {
    return 0x00008100;
  }
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctaaSigPrep1_PpaseSigPrep1SubCanDiagInfo_sSubCanDiagInfo(P2CONST(tisSubCanDiagInfo, AUTOMATIC, RTE_CTAASIGPREP1_APPL_DATA) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PpareClamp2LightClamp2Light_AFSCommand_sClamp2Light_AFSCommand(P2VAR(tisClamp2Light_AFSCommand, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(uint32, ctaaSigPrep1_CODE) E2EPW_Write_PpsseSigPrep1AFSCommand_sAFSCommand(P2VAR(SG_sigGrpAfsCommand, AUTOMATIC, ctaaSigPrep1_VAR_INIT) AppData)
{
  return 0;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PparePlsRPlsR0_CeremonyCmd1_sPlsR0_CeremonyCmd1(P2VAR(tisPlsR_CeremonyCmd1, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctaaSigPrep1_PpsseSigPrep1CeremonyCmdLeft1_sCeremonyCmdLeft1(P2CONST(SG_sigGrpCeremonyCmdLeft1, AUTOMATIC, RTE_CTAASIGPREP1_APPL_DATA) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PparePlsRPlsR0_CeremonyCmd2_sPlsR0_CeremonyCmd2(P2VAR(tisPlsR_CeremonyCmd2, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctaaSigPrep1_PpsseSigPrep1CeremonyCmdLeft2_sCeremonyCmdLeft2(P2CONST(SG_sigGrpCeremonyCmdLeft2, AUTOMATIC, RTE_CTAASIGPREP1_APPL_DATA) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PparePlsRPlsR1_CeremonyCmd1_sPlsR1_CeremonyCmd1(P2VAR(tisPlsR_CeremonyCmd1, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctaaSigPrep1_PpsseSigPrep1CeremonyCmdRight1_sCeremonyCmdRight1(P2CONST(SG_sigGrpCeremonyCmdRight1, AUTOMATIC, RTE_CTAASIGPREP1_APPL_DATA) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PparePlsRPlsR1_CeremonyCmd2_sPlsR1_CeremonyCmd2(P2VAR(tisPlsR_CeremonyCmd2, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Write_ctaaSigPrep1_PpsseSigPrep1CeremonyCmdRight2_sCeremonyCmdRight2(P2CONST(SG_sigGrpCeremonyCmdRight2, AUTOMATIC, RTE_CTAASIGPREP1_APPL_DATA) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PpareClamp2LightClamp2Light_LightControlCommand_sClamp2Light_LightControlCommand(P2VAR(tisClamp2Light_LightControlCommand, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(uint32, ctaaSigPrep1_CODE) E2EPW_Write_PpsseSigPrep1ControlCommand_sLightControlCommand(P2VAR(SG_sigGrpLightControlCommand, AUTOMATIC, ctaaSigPrep1_VAR_INIT) AppData)
{
  return 0;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PpareClamp2LightClamp2Light_MatrixHBCommand_sClamp2Light_MatrixHBCommand(P2VAR(tisClamp2Light_MatrixHBCommand, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(uint32, ctaaSigPrep1_CODE) E2EPW_Write_PpsseSigPrep1MatrixHBCommand_sMatrixHBCommand(P2VAR(SG_sigGrpMatrixHbCommmand, AUTOMATIC, ctaaSigPrep1_VAR_INIT) AppData)
{
  return 0;
}

FUNC(Std_ReturnType, ctaaVehicleHub_CODE) PpasvVehHubVehicleDynamic_ReadData(P2VAR(tisVehicleDynamic, AUTOMATIC, RTE_CTAAVEHICLEHUB_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(uint32, ctaaSigPrep1_CODE) E2EPW_Write_PpsseSigPrep1VehicleInfo1_sVehicleInfo1(P2VAR(SG_sigGrpVehicleInfo, AUTOMATIC, ctaaSigPrep1_VAR_INIT) AppData)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, ctaaVehicleHub_CODE) PpasvVehHubGeneralInfo_ReadData(P2VAR(tisGeneralInfo, AUTOMATIC, RTE_CTAAVEHICLEHUB_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, ctaaVehicleHub_CODE) PpasvVehHubGlobalTime_ReadData(P2VAR(tisGlobalTime, AUTOMATIC, RTE_CTAAVEHICLEHUB_APPL_VAR) data)
{
  return RTE_E_OK;
}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PparePlsRPlsR_VehicleInfo_sPlsR_VehicleInfo(P2VAR(tisPlsR_VehicleInfo, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

//static void SigPrep1_GetAfsCommandFaultErrorSts(void)
//{
//
//}

FUNC(Std_ReturnType, RTE_CODE) Rte_Read_ctaaSigPrep1_PpareStpMStpMVerticalTgt_sStpMVerticalTgt(P2VAR(tisStpMVerticalTgt, AUTOMATIC, RTE_CTAASIGPREP1_APPL_VAR) data)
{
  return RTE_E_OK;
}

/* SigPrep1.c*/
//-----------------------------------------------------------------------------
/// \Test Case : Mt_RTE_Can1HLMLStatesInfoMsg
///
/// \Test Case Description
///    - Test subject:
///        Call the RTE runnable RTE_Can1HLMLStatesInfoMsg(boolean status).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_RTE_Can1HLMLStatesInfoMsg(void)
{
	RTE_Can1HLMLStatesInfoMsg( 0 );
}

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

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

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

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

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

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

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

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

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

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

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

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

/* SigPrep1_Common.c*/

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_divAndRoundClosest
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_divAndRoundClosest(uint32 dividend, uint32 divisor).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1_divAndRoundClosest(void)
{
  SigPrep1_divAndRoundClosest_result = SigPrep1_divAndRoundClosest(dividend,divisor);
  AL_UNITTEST_CHECK(SigPrep1_divAndRoundClosest_result, dividend, == );

  divisor = 4;
  dividend = 4;
  SigPrep1_divAndRoundClosest_result = SigPrep1_divAndRoundClosest(dividend,divisor);
  AL_UNITTEST_CHECK(SigPrep1_divAndRoundClosest_result, 1, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1CheckRteAndSignalSetQuality
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1CheckRteAndSignalSetQuality(Std_ReturnType retVal, uint16 valInvalid, tSigPrep1Signal_Val *pSig, boolean value).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1CheckRteAndSignalSetQuality(void)
{
  quality.monitor.isDebounced = 0;
  quality.monitor.cnt = 0;
  quality.monitor.cntActivate = 10;
  quality.state = eSigPrep1SigState_Valid;
  Sig.value = 0;
  Sig.valueOld = 0;
  Sig.quality = quality;

  SigPrep1CheckRteAndSignalSetQuality( retVal, valInvalid, &Sig, value);
  AL_UNITTEST_CHECK(Sig.valueOld, 0, == );

  retVal = RTE_E_OK;
  value = TRUE;
  Sig.value = 20;
  SigPrep1CheckRteAndSignalSetQuality( retVal, valInvalid, &Sig, value);
  AL_UNITTEST_CHECK(Sig.valueOld, Sig.value, == );

  retVal = RTE_E_OK;
  value = FALSE;
  Sig.valueOld = 0;
  SigPrep1CheckRteAndSignalSetQuality( retVal, valInvalid, &Sig, value);
  AL_UNITTEST_CHECK(Sig.valueOld, 0, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1CheckRteAndusSignalSetQuality
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1CheckRteAndusSignalSetQuality(Std_ReturnType retVal, uint16 valInvalid, tSigPrep1Signal_Val *pSig, boolean value).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1CheckRteAndusSignalSetQuality(void)
{
  usSig.value = 0;
  usSig.valueOld = 0;
  quality.monitor.isDebounced = 0;
  quality.monitor.cnt = 0;
  quality.monitor.cntActivate = 10;
  quality.state = eSigPrep1SigState_Valid;
  usSig.quality = quality;
  SigPrep1CheckRteAndusSignalSetQuality( retVal, valInvalid, &usSig, value);
  AL_UNITTEST_CHECK(usSig.valueOld, 0, == );

  retVal = RTE_E_OK;
  value = TRUE;
  usSig.value = 20;
  SigPrep1CheckRteAndusSignalSetQuality( retVal, valInvalid, &usSig, value);
  AL_UNITTEST_CHECK(usSig.valueOld, usSig.value, == );

  retVal = RTE_E_OK;
  value = FALSE;
  usSig.valueOld = 0;
  SigPrep1CheckRteAndusSignalSetQuality( retVal, valInvalid, &usSig, value);
  AL_UNITTEST_CHECK(usSig.valueOld, 0, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_MemSet
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_MemSet(uint8 *buf,uint8 value,uint16 size).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_MemSet(void)
{
  uint8 i;
  value2 = 3;
  SigPrep1_MemSet(buff, value2, size);
  for(i=0;i<size;i++)
  {
    AL_UNITTEST_CHECK(buff[i], 3, == );
  }
}



/* SigPrep1Rx.c*/


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_initCounterMonitor
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_initCounterMonitor(tSigPrep1CounterMonitor* const pCntMon, uint32 nLimitActivate, uint32 nLimitDeActivate).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_initCounterMonitor(void)
{
  SigPrep1Rx_initCounterMonitor(&CounterMonitor, nLimitActivate, nLimitDeActivate);
  AL_UNITTEST_CHECK(CounterMonitor.cntActivate, nLimitActivate, == );
  AL_UNITTEST_CHECK(CounterMonitor.cntDeActivate, nLimitDeActivate, == );
  AL_UNITTEST_CHECK(CounterMonitor.isDebounced, FALSE, == );
  AL_UNITTEST_CHECK(CounterMonitor.cnt, 0, == );
  AL_UNITTEST_CHECK(CounterMonitor.isActiveDtc, FALSE, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_initTimerMonitor
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_initTimerMonitor(tSigPrep1TimerMonitor* const pTimMon, uint32 nToutActivateMsec, uint32 nToutDeActivateMsec).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_initTimerMonitor(void)
{
  SigPrep1Rx_initTimerMonitor(&TimerMonitor, nToutActivateMsec, nToutDeActivateMsec);
  AL_UNITTEST_CHECK(TimerMonitor.toutActivate, nToutActivateMsec, == );
  AL_UNITTEST_CHECK(TimerMonitor.toutDeActivate, nToutDeActivateMsec, == );
  AL_UNITTEST_CHECK(TimerMonitor.isTimeout, FALSE, == );
  AL_UNITTEST_CHECK(TimerMonitor.isActiveDtc, FALSE, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_initPduQualityE2E
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_initPduQualityE2E(tSigPrep1PduQualityE2E* const pQuality, uint32 nTcyclicMsec, uint32 nToutMsec).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1Rx_initPduQualityE2E(void)
{
  SigPrep1Rx_initPduQualityE2E(&PduQualityE2E, 3, 2);
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HandleSignalQualitySuccess
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HandleSignalQualitySuccess(tSigPrep1SignalQuality* const pQuality).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1Rx_HandleSignalQualitySuccess(void)
{
  CounterMonitor.cnt = 1;
  SignalQuality.monitor = CounterMonitor;
  SigPrep1Rx_HandleSignalQualitySuccess(&SignalQuality);
  AL_UNITTEST_CHECK(SignalQuality.monitor.cnt, 0, == );

  CounterMonitor.cnt = 0;
  SigPrep1Rx_HandleSignalQualitySuccess(&SignalQuality);
  AL_UNITTEST_CHECK(SignalQuality.monitor.isDebounced, FALSE, == );
}



//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HandleSignalQualityFail
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HandleSignalQualityFail(tSigPrep1SignalQuality* const pQuality).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1Rx_HandleSignalQualityFail(void)
{
  CounterMonitor.cnt = 5;
  CounterMonitor.cntActivate = 10;
  CounterMonitor.isDebounced = FALSE;
  SignalQuality.state = eSigPrep1SigState_Valid;
  SignalQuality.monitor = CounterMonitor;
  SigPrep1Rx_HandleSignalQualityFail(&SignalQuality);
  AL_UNITTEST_CHECK(SignalQuality.monitor.cnt, 6, == );
  AL_UNITTEST_CHECK(SignalQuality.state, eSigPrep1SigState_PreInvalid, == );
  
  CounterMonitor.isDebounced = FALSE;
  CounterMonitor.cnt = 5;
  CounterMonitor.cntActivate = 3;
  CounterMonitor.cntDeActivate = 10;
  SignalQuality.monitor = CounterMonitor;
  SigPrep1Rx_HandleSignalQualityFail(&SignalQuality);
  AL_UNITTEST_CHECK(SignalQuality.monitor.isDebounced, TRUE, == );
  AL_UNITTEST_CHECK(SignalQuality.state, eSigPrep1SigState_Invalid, == );
  AL_UNITTEST_CHECK(SignalQuality.monitor.cnt, CounterMonitor.cntDeActivate, == );

  CounterMonitor.isDebounced = TRUE;
  CounterMonitor.cnt = 5;
  CounterMonitor.cntActivate = 10;
  SignalQuality.state = eSigPrep1SigState_Valid;
  SignalQuality.monitor = CounterMonitor;
  SigPrep1Rx_HandleSignalQualityFail(&SignalQuality);
  AL_UNITTEST_CHECK(SignalQuality.monitor.cnt, 6, == );
  AL_UNITTEST_CHECK(SignalQuality.state, eSigPrep1SigState_PreInvalid, == );

  CounterMonitor.isDebounced = TRUE;
  CounterMonitor.cnt = 5;
  CounterMonitor.cntActivate = 3;
  SignalQuality.monitor = CounterMonitor;
  SigPrep1Rx_HandleSignalQualityFail(&SignalQuality);
  AL_UNITTEST_CHECK(SignalQuality.state, eSigPrep1SigState_Invalid, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HandlePduQualityE2ESuccess
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HandlePduQualityE2ESuccess(tSigPrep1PduQualityE2E* const pQuality).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1Rx_HandlePduQualityE2ESuccess(void)
{
  SigPrep1Rx_HandlePduQualityE2ESuccess(&PduQualityE2E);
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HandlePduQualityCounterMonitorSuccess
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HandlePduQualityCounterMonitorSuccess(tSigPrep1CounterMonitor* const pCntMon).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1Rx_HandlePduQualityCounterMonitorSuccess(void)
{
  CounterMonitor.cnt = 1;
  SigPrep1Rx_HandlePduQualityCounterMonitorSuccess(&CounterMonitor);
  AL_UNITTEST_CHECK(CounterMonitor.cnt,0, == );

  CounterMonitor.cnt = 0;
  SigPrep1Rx_HandlePduQualityCounterMonitorSuccess(&CounterMonitor);
  AL_UNITTEST_CHECK(CounterMonitor.isDebounced,FALSE, == );
}



//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HandlePduQualityCounterMonitorFail
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HandlePduQualityCounterMonitorFail(tSigPrep1CounterMonitor* const pCntMon).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1Rx_HandlePduQualityCounterMonitorFail(void)
{
  CounterMonitor.isDebounced = FALSE;
  CounterMonitor.cnt = 1;
  CounterMonitor.cntActivate = 5;
  SigPrep1Rx_HandlePduQualityCounterMonitorFail(&CounterMonitor);
  AL_UNITTEST_CHECK(CounterMonitor.cnt,2, == );

  CounterMonitor.isDebounced = FALSE;
  CounterMonitor.cnt = 5;
  CounterMonitor.cntActivate = 1;
  CounterMonitor.cntDeActivate = 2;
  SigPrep1Rx_HandlePduQualityCounterMonitorFail(&CounterMonitor);
  AL_UNITTEST_CHECK(CounterMonitor.cnt,CounterMonitor.cntDeActivate, == );
  AL_UNITTEST_CHECK(CounterMonitor.isDebounced,TRUE, == );

  CounterMonitor.isDebounced = TRUE;
  CounterMonitor.cnt = 1;
  CounterMonitor.cntDeActivate = 2;
  SigPrep1Rx_HandlePduQualityCounterMonitorFail(&CounterMonitor);
  AL_UNITTEST_CHECK(CounterMonitor.cnt,2, == );

  SigPrep1Rx_HandlePduQualityCounterMonitorFail(&CounterMonitor);
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HandlePduQualityE2EFail
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HandlePduQualityE2EFail(tSigPrep1PduQualityE2E* const pQuality, const SigPrep1_EnumErrorIndicationType eErrIndType).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------

void Mt_SigPrep1Rx_HandlePduQualityE2EFail(void)
{
  MonitorE2E.monitorAliveCounter.monitorFail.isDebounced = TRUE;
  PduQualityE2E.monitor = MonitorE2E;
  SigPrep1Rx_HandlePduQualityE2EFail(&PduQualityE2E, eSigPrep1ErrIndRteAliveCounter);
  AL_UNITTEST_CHECK(PduQualityE2E.state,eSigPrep1PduState_Failed, == );

  MonitorE2E.monitorAliveCounter.monitorFail.isDebounced = FALSE;
  PduQualityE2E.monitor = MonitorE2E;
  SigPrep1Rx_HandlePduQualityE2EFail(&PduQualityE2E, eSigPrep1ErrIndRteAliveCounter);

  MonitorE2E.monitorAliveCounter.monitorFail.isDebounced = TRUE;
  PduQualityE2E.monitor = MonitorE2E;
  SigPrep1Rx_HandlePduQualityE2EFail(&PduQualityE2E, eSigPrep1ErrIndRteCrc);
  AL_UNITTEST_CHECK(PduQualityE2E.state,eSigPrep1PduState_Failed, == );

  MonitorE2E.monitorAliveCounter.monitorFail.isDebounced = FALSE;
  PduQualityE2E.monitor = MonitorE2E;
  SigPrep1Rx_HandlePduQualityE2EFail(&PduQualityE2E, eSigPrep1ErrIndRteCrc);

  PduQualityE2E.monitor = MonitorE2E;
  SigPrep1Rx_HandlePduQualityE2EFail(&PduQualityE2E, eSigPrep1ErrIndRteTimeout);
  AL_UNITTEST_CHECK(PduQualityE2E.state,eSigPrep1PduState_Failed, == );

  MonitorE2E.monitorSelfTimer.isTimeout = TRUE;
  PduQualityE2E.monitor = MonitorE2E;
  SigPrep1Rx_HandlePduQualityE2EFail(&PduQualityE2E, eSigPrep1ErrIndSelfTimeout);
  AL_UNITTEST_CHECK(PduQualityE2E.state,eSigPrep1PduState_Failed, == );

  MonitorE2E.monitorSelfTimer.isTimeout = FALSE;
  PduQualityE2E.state = eSigPrep1PduState_Passed;
  PduQualityE2E.monitor = MonitorE2E;
  SigPrep1Rx_HandlePduQualityE2EFail(&PduQualityE2E, eSigPrep1ErrIndSelfTimeout);
  AL_UNITTEST_CHECK(PduQualityE2E.state,eSigPrep1PduState_PreFailed, == );

}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_GetE2E_ErrorIndication
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_GetE2E_ErrorIndication(uint32 E2E_ReadReturnVal).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_GetE2E_ErrorIndication(void)
{
  E2E_ReadReturnVal = 0x03000000;
  GetE2E_ErrorIndicationResult = SigPrep1Rx_GetE2E_ErrorIndication(E2E_ReadReturnVal);
  AL_UNITTEST_CHECK(GetE2E_ErrorIndicationResult,eSigPrep1ErrNone, == );

  E2E_ReadReturnVal = 0x20010000;
  GetE2E_ErrorIndicationResult = SigPrep1Rx_GetE2E_ErrorIndication(E2E_ReadReturnVal);
  AL_UNITTEST_CHECK(GetE2E_ErrorIndicationResult,eSigPrep1ErrNone, == );

  E2E_ReadReturnVal = 0x02008017;
  GetE2E_ErrorIndicationResult = SigPrep1Rx_GetE2E_ErrorIndication(E2E_ReadReturnVal);
  AL_UNITTEST_CHECK(GetE2E_ErrorIndicationResult,eSigPrep1ErrIndRteCrc, == );

  E2E_ReadReturnVal = 0x20002019;
  GetE2E_ErrorIndicationResult = SigPrep1Rx_GetE2E_ErrorIndication(E2E_ReadReturnVal);
  AL_UNITTEST_CHECK(GetE2E_ErrorIndicationResult,eSigPrep1ErrIndRteTimeout, == );
}


/* SigPrep1_MsgAFSCommandTx.c */

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_AFSCommand_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_AFSCommand_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_AFSCommand_Init(void)
{
  SigPrep1Tx_AFSCommand_Init();
  AL_UNITTEST_CHECK(sAFSCommand.TargetPstnVer_LR, 0x3FF, == );
  AL_UNITTEST_CHECK(sStpMVerticalTgt.usTargetAngleLR, 0x3FF, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxAFSCommand
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxAFSCommand().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxAFSCommand(void)
{
  sClamp2Light_AFSCommand.boAFSEnable = 1;
  sClamp2Light_AFSCommand.eAFSModeCmd = 1;
  sStpMVerticalTgt.eReferenceLeft = 1;
  sStpMVerticalTgt.eReferenceRight = 1;
  sStpMVerticalTgt.eSafetyOpLeft = 1;
  sStpMVerticalTgt.eSafetyOpRight = 1;
  sStpMVerticalTgt.usTargetAngleLR = 1;
  SigPrep1_Can1TxAFSCommand();
  AL_UNITTEST_CHECK(sAFSCommand.AFS_Enable, sClamp2Light_AFSCommand.boAFSEnable, == );
  AL_UNITTEST_CHECK(sAFSCommand.AFSModeCmd, sClamp2Light_AFSCommand.eAFSModeCmd, == );
  AL_UNITTEST_CHECK(sAFSCommand.ReferenceVer_Left, sStpMVerticalTgt.eReferenceLeft, == );
  AL_UNITTEST_CHECK(sAFSCommand.ReferenceVer_Right, sStpMVerticalTgt.eReferenceRight, == );
  AL_UNITTEST_CHECK(sAFSCommand.SafetyPstnVer_Left, sStpMVerticalTgt.eSafetyOpLeft, == );
  AL_UNITTEST_CHECK(sAFSCommand.SafetyPstnVer_Right, sStpMVerticalTgt.eSafetyOpRight, == );
  AL_UNITTEST_CHECK(sAFSCommand.TargetPstnVer_LR, sStpMVerticalTgt.usTargetAngleLR, == );
}

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

/* SigPrep1_MsgCeremonyCmdLeft1Tx.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_CeremonyCmdLeft1_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_CeremonyCmdLeft1_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_CeremonyCmdLeft1_Init(void)
{
  SigPrep1Tx_CeremonyCmdLeft1_Init();
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxCeremonyCmdLeft1
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxCeremonyCmdLeft1().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxCeremonyCmdLeft1(void)
{
  sPlsR_CeremonyCmd1_0.ucCereCmdSeqnCnt = 1;
  sPlsR_CeremonyCmd1_0.ucCereSegment01 = 2;
  sPlsR_CeremonyCmd1_0.ucCereSegment30 = 3;
  sPlsR_CeremonyCmd1_0.ucCereSegment59 = 4;
  sPlsR_CeremonyCmd1_0.ucCereSegment60 = 5;
  SigPrep1_Can1TxCeremonyCmdLeft1();
  AL_UNITTEST_CHECK(sCeremonyCmdLeft1.CereCmdLeft1_SeqnCnt, sPlsR_CeremonyCmd1_0.ucCereCmdSeqnCnt, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft1.Left1CereSegment01, sPlsR_CeremonyCmd1_0.ucCereSegment01, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft1.Left1CereSegment30, sPlsR_CeremonyCmd1_0.ucCereSegment30, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft1.Left1CereSegment59, sPlsR_CeremonyCmd1_0.ucCereSegment59, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft1.Left1CereSegment60, sPlsR_CeremonyCmd1_0.ucCereSegment60, == );

}

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

/* SigPrep1_MsgCeremonyCmdLeft2Tx.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_CeremonyCmdLeft2_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_CeremonyCmdLeft2_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_CeremonyCmdLeft2_Init(void)
{
  SigPrep1Tx_CeremonyCmdLeft2_Init();
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxCeremonyCmdLeft2
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxCeremonyCmdLeft2().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxCeremonyCmdLeft2(void)
{
  sPlsR_CeremonyCmd2_0.ucCereCmdSeqnCnt = 1;
  sPlsR_CeremonyCmd2_0.ucCereSegment01 = 2;
  sPlsR_CeremonyCmd2_0.ucCereSegment10 = 3;
  sPlsR_CeremonyCmd2_0.ucCereSegment20 = 4;
  sPlsR_CeremonyCmd2_0.ucCereSegment21 = 5;
  SigPrep1_Can1TxCeremonyCmdLeft2();
  AL_UNITTEST_CHECK(sCeremonyCmdLeft2.CereCmdLeft2_SeqnCnt, sPlsR_CeremonyCmd2_0.ucCereCmdSeqnCnt, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft2.Left2CereSegment01, sPlsR_CeremonyCmd2_0.ucCereSegment01, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft2.Left2CereSegment10, sPlsR_CeremonyCmd2_0.ucCereSegment10, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft2.Left2CereSegment20, sPlsR_CeremonyCmd2_0.ucCereSegment20, == );
  AL_UNITTEST_CHECK(sCeremonyCmdLeft2.Left2CereSegment21, sPlsR_CeremonyCmd2_0.ucCereSegment21, == );

}

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

/* SigPrep1_MsgCeremonyCmdRight1Tx.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_CeremonyCmdRight1_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_CeremonyCmdRight1_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_CeremonyCmdRight1_Init(void)
{
  SigPrep1Tx_CeremonyCmdRight1_Init();
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxCeremonyCmdRight1
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxCeremonyCmdRight1().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxCeremonyCmdRight1(void)
{
  sPlsR_CeremonyCmd1_1.ucCereCmdSeqnCnt = 1;
  sPlsR_CeremonyCmd1_1.ucCereSegment01 = 2;
  sPlsR_CeremonyCmd1_1.ucCereSegment30 = 3;
  sPlsR_CeremonyCmd1_1.ucCereSegment59 = 4;
  sPlsR_CeremonyCmd1_1.ucCereSegment60 = 5;
  SigPrep1_Can1TxCeremonyCmdRight1();
  AL_UNITTEST_CHECK(sCeremonyCmdRight1.CereCmdRight1_SeqnCnt, sPlsR_CeremonyCmd1_1.ucCereCmdSeqnCnt, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight1.Right1CereSegment01, sPlsR_CeremonyCmd1_1.ucCereSegment01, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight1.Right1CereSegment30, sPlsR_CeremonyCmd1_1.ucCereSegment30, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight1.Right1CereSegment59, sPlsR_CeremonyCmd1_1.ucCereSegment59, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight1.Right1CereSegment60, sPlsR_CeremonyCmd1_1.ucCereSegment60, == );

}

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

/* SigPrep1_MsgCeremonyCmdRight2Tx.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_CeremonyCmdRight2_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_CeremonyCmdRight2_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_CeremonyCmdRight2_Init(void)
{
  SigPrep1Tx_CeremonyCmdRight2_Init();
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxCeremonyCmdRight2
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxCeremonyCmdRight2().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxCeremonyCmdRight2(void)
{
  sPlsR_CeremonyCmd2_1.ucCereCmdSeqnCnt = 1;
  sPlsR_CeremonyCmd2_1.ucCereSegment01 = 2;
  sPlsR_CeremonyCmd2_1.ucCereSegment10 = 3;
  sPlsR_CeremonyCmd2_1.ucCereSegment20 = 4;
  sPlsR_CeremonyCmd2_1.ucCereSegment21 = 5;
  SigPrep1_Can1TxCeremonyCmdRight2();
  AL_UNITTEST_CHECK(sCeremonyCmdRight2.CereCmdRight2_SeqnCnt, sPlsR_CeremonyCmd2_1.ucCereCmdSeqnCnt, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight2.Right2CereSegment01, sPlsR_CeremonyCmd2_1.ucCereSegment01, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight2.Right2CereSegment10, sPlsR_CeremonyCmd2_1.ucCereSegment10, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight2.Right2CereSegment20, sPlsR_CeremonyCmd2_1.ucCereSegment20, == );
  AL_UNITTEST_CHECK(sCeremonyCmdRight2.Right2CereSegment21, sPlsR_CeremonyCmd2_1.ucCereSegment21, == );

}

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

/* SigPrep1_MsgHLMLStatesInfo.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_Can1HLMLStatesInfoMsg
///
/// \Test Case Description
///    - Test subject:
///        Call runnable Can1HLMLStatesInfoMsg(boolean status).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_Can1HLMLStatesInfoMsg(void)
{
  Can1HLMLStatesInfoMsg(0);
  Can1HLMLStatesInfoMsg(1);
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1HLMLStatesInfoMsg
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1HLMLStatesInfoMsg().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1HLMLStatesInfoMsg(void)
{
  PpsreComHLMLSTATESInfo_sHLMLSTATESInfo = eSigPrep1ErrNone;
  msg_HLM_L_STATES_Info.quality.monitor.monitorAliveCounter.monitorFail.cnt = 0;
  msg_HLM_L_STATES_Info.quality.monitor.monitorCrc.monitorFail.cnt = 0;
  SigPrep1_Can1HLMLStatesInfoMsg();
  AL_UNITTEST_CHECK(msg_HLM_L_STATES_Info.quality.state, eSigPrep1PduState_Passed, == );

  PpsreComHLMLSTATESInfo_sHLMLSTATESInfo =  eSigPrep1ErrNone;
  msg_HLM_L_STATES_Info.quality.monitor.monitorAliveCounter.monitorFail.cnt = 10;
  msg_HLM_L_STATES_Info.quality.monitor.monitorCrc.monitorFail.cnt = 10;
  msg_HLM_L_STATES_Info.quality.monitor.monitorAliveCounter.monitorFail.isDebounced = TRUE;
  msg_HLM_L_STATES_Info.quality.monitor.monitorCrc.monitorFail.isDebounced = TRUE;
  SigPrep1_Can1HLMLStatesInfoMsg();
  AL_UNITTEST_CHECK(msg_HLM_L_STATES_Info.quality.state, eSigPrep1PduState_Failed, == );

  PpsreComHLMLSTATESInfo_sHLMLSTATESInfo = eSigPrep1ErrIndRteTimeout;
  sHLMLSTATESInfo.ErrVer_HLM_L = 0xf8;
  SigPrep1_Can1HLMLStatesInfoMsg();
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1HLMLStatesInfoMsgFail
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1HLMLStatesInfoMsgFail().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1HLMLStatesInfoMsgFail(void)
{
  SigPrep1_Can1HLMLStatesInfoMsgFail();
  AL_UNITTEST_CHECK(msg_HLM_L_STATES_Info.quality.state, eSigPrep1PduState_Failed, == );
}

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


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_initSignalData_HLMLStatesInfo
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_initSignalData_HLMLStatesInfo().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_initSignalData_HLMLStatesInfo(void)
{
  SigPrep1_initSignalData_HLMLStatesInfo();
  AL_UNITTEST_CHECK(msg_HLM_L_STATES_Info.data.sig_HLM_L_STATES_Info_CheckSum.value, SIGPREP1_HLMLSTATESINFO_MESSAGE_INITVAL, == );
  AL_UNITTEST_CHECK(msg_HLM_L_STATES_Info.data.sig_Fault_HLM_L_FAN.value, 0x7, == );
  AL_UNITTEST_CHECK(msg_HLM_L_STATES_Info.data.sig_SupplyVoltage_HLM_L.valueOld, msg_HLM_L_STATES_Info.data.sig_SupplyVoltage_HLM_L.value, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1RxForwardToSwc_HLMLStatesInfo
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1RxForwardToSwc_HLMLStatesInfo(SigPrep1_EnumErrorIndicationType eErr).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1RxForwardToSwc_HLMLStatesInfo(void)
{
  GetHLMLStatesInfoResult = SigPrep1RxForwardToSwc_HLMLStatesInfo(1);
  AL_UNITTEST_CHECK(GetHLMLStatesInfoResult, RTE_E_OK, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct1
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct1(uint8 ucValue1, uint8 ucValue2, uint8 ucValue3, uint8 ucValue4, uint8 ucValue5, uint8 ucValue6, uint8 ucValue7).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct1(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct1(1,2,3,4,5,6,7);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eHLMBoardState, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eHLMInternalState, 2, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boHLMCommState, 3, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMLBBase, 4, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMLBBase, 5, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMLBSIG, 6, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMLBSIG, 7, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct2
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct2(uint8 ucValue1, uint8 ucValue2, uint8 ucValue3, uint8 ucValue4, uint8 ucValue5, uint8 ucValue6, uint8 ucValue7, uint8 ucValue8).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct2(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct2(1,2,3,4,5,6,7,8);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMHB, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMHB, 2, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMDRL, 3, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMDRL, 4, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMPOS, 5, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMPOS, 6, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMTI, 7, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMTI, 8, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct3
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct3(uint8 ucValue1, uint8 ucValue2, uint8 ucValue3, uint8 ucValue4, uint8 ucValue5, uint8 ucValue6, uint8 ucValue7, uint8 ucValue8).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct3(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct3(1,2,3,4,5,6,7,8);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMCL, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMCL, 2, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMCeremony, 3, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boStateHLMFAN, 4, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eFaultHLMFAN, 5, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.usValueVerHLM, 6, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eStatusVerHLM, 7, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.boSPStateVerHLM, 8, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct4
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct4(uint8 ucValue1, uint8 ucValue2).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct4(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct4(1,2);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.eErrVerHLM, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc0.ucSupplyVoltageHLM, 2, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1RxForwardPrepare_HLM_L_STATES_Info
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1RxForwardPrepare_HLM_L_STATES_Info(SigPrep1_EnumErrorIndicationType eErr).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1RxForwardPrepare_HLM_L_STATES_Info(void)
{
  msg_HLM_L_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrep1RxForwardPrepare_HLM_L_STATES_Info(eSigPrep1ErrIndRteTimeout);

  msg_HLM_L_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrep1RxForwardPrepare_HLM_L_STATES_Info(eSigPrep1ErrIndRteCrc);

  msg_HLM_L_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrep1RxForwardPrepare_HLM_L_STATES_Info(eSigPrep1ErrIndRteAliveCounter);

  msg_HLM_L_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrep1RxForwardPrepare_HLM_L_STATES_Info(eSigPrep1ErrNone);

  msg_HLM_L_STATES_Info.quality.state = eSigPrep1PduState_PreFailed;
  SigPrep1RxForwardPrepare_HLM_L_STATES_Info(eSigPrep1ErrNone);
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1RxProcessMsg_HLM_L_STATES_Info
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1RxProcessMsg_HLM_L_STATES_Info().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1RxProcessMsg_HLM_L_STATES_Info(void)
{
  sHLMLSTATESInfo.HLM_L_Internal_State = 1;
  GetHLM_L_STATES_InfoResult = SigPrep1RxProcessMsg_HLM_L_STATES_Info();
  AL_UNITTEST_CHECK(msg_HLM_L_STATES_Info.data.sig_HLM_L_Internal_State.value,sHLMLSTATESInfo.HLM_L_Internal_State, == );
  AL_UNITTEST_CHECK(GetHLM_L_STATES_InfoResult, RTE_E_OK, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HLM_L_STATES_Info_SetQty
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HLM_L_STATES_Info_SetQty(tibfQtyStsBits tieQty).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_HLM_L_STATES_Info_SetQty(void)
{
  SigPrep1Rx_HLM_L_STATES_Info_SetQty(eSigPrep1PduState_Passed);
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmLStatesInfo.boE2eRes,0, == );
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmLStatesInfo.boTimeout, 0, == );

  SigPrep1Rx_HLM_L_STATES_Info_SetQty(TIMEOUT_ERROR);
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmLStatesInfo.boE2eRes,0, == );
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmLStatesInfo.boTimeout, 1, == );

  SigPrep1Rx_HLM_L_STATES_Info_SetQty(eSigPrep1PduState_Last);
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmLStatesInfo.boE2eRes,1, == );
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmLStatesInfo.boTimeout, 0, == );
}

/* SigPrep1_MsgHLMRStatesInfo.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_Can1HLMRStatesInfoMsg
///
/// \Test Case Description
///    - Test subject:
///        Call runnable Can1HLMRStatesInfoMsg(boolean status).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_Can1HLMRStatesInfoMsg(void)
{
  Can1HLMRStatesInfoMsg(0);
  Can1HLMRStatesInfoMsg(1);
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1HLMRStatesInfoMsg
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1HLMRStatesInfoMsg().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1HLMRStatesInfoMsg(void)
{
  PpsreComHLMRSTATESInfo_sHLMRSTATESInfo = eSigPrep1ErrNone;
  msg_HLM_R_STATES_Info.quality.monitor.monitorAliveCounter.monitorFail.cnt = 0;
  msg_HLM_R_STATES_Info.quality.monitor.monitorCrc.monitorFail.cnt = 0;
  SigPrep1_Can1HLMRStatesInfoMsg();
  AL_UNITTEST_CHECK(msg_HLM_R_STATES_Info.quality.state, eSigPrep1PduState_Passed, == );

  PpsreComHLMRSTATESInfo_sHLMRSTATESInfo = eSigPrep1ErrNone;
  msg_HLM_R_STATES_Info.quality.monitor.monitorAliveCounter.monitorFail.cnt = 10;
  msg_HLM_R_STATES_Info.quality.monitor.monitorCrc.monitorFail.cnt = 10;
  msg_HLM_R_STATES_Info.quality.monitor.monitorAliveCounter.monitorFail.isDebounced = TRUE;
  msg_HLM_R_STATES_Info.quality.monitor.monitorCrc.monitorFail.isDebounced = TRUE;
  SigPrep1_Can1HLMRStatesInfoMsg();
  AL_UNITTEST_CHECK(msg_HLM_R_STATES_Info.quality.state, eSigPrep1PduState_Failed, == );

  PpsreComHLMRSTATESInfo_sHLMRSTATESInfo = eSigPrep1ErrIndRteTimeout;
  Rte_RxUpdateFlags.Rte_RxUpdate_ctaaSigPrep1_PpsreComHLMLSTATESInfo_sHLMLSTATESInfo == 1;
  sHLMLSTATESInfo.ErrVer_HLM_L = 0xf8;
  SigPrep1_Can1HLMRStatesInfoMsg();
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1HLMRStatesInfoMsgFail
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1HLMRStatesInfoMsgFail().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1HLMRStatesInfoMsgFail(void)
{
  SigPrep1_Can1HLMRStatesInfoMsgFail();
  AL_UNITTEST_CHECK(msg_HLM_R_STATES_Info.quality.state, eSigPrep1PduState_Failed, == );
}

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


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_initSignalData_HLMRStatesInfo
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_initSignalData_HLMRStatesInfo().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_initSignalData_HLMRStatesInfo(void)
{
  SigPrep1_initSignalData_HLMRStatesInfo();
  AL_UNITTEST_CHECK(msg_HLM_R_STATES_Info.data.sig_HLM_R_STATES_Info_CheckSum.value, SIGPREP1_HLMRSTATESINFO_MESSAGE_INITVAL, == );
  AL_UNITTEST_CHECK(msg_HLM_R_STATES_Info.data.sig_Fault_HLM_R_FAN.value, 0x7, == );
  AL_UNITTEST_CHECK(msg_HLM_R_STATES_Info.data.sig_SupplyVoltage_HLM_R.valueOld, msg_HLM_R_STATES_Info.data.sig_SupplyVoltage_HLM_R.value, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1RxForwardToSwc_HLMRStatesInfo
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1RxForwardToSwc_HLMRStatesInfo(SigPrep1_EnumErrorIndicationType eErr).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1RxForwardToSwc_HLMRStatesInfo(void)
{
  GetHLMRStatesInfoResult = SigPrep1RxForwardToSwc_HLMRStatesInfo(1);
  AL_UNITTEST_CHECK(GetHLMRStatesInfoResult, RTE_E_OK, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct1
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct1(uint8 ucValue1, uint8 ucValue2, uint8 ucValue3, uint8 ucValue4, uint8 ucValue5, uint8 ucValue6, uint8 ucValue7).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct1(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct1(1,2,3,4,5,6,7);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eHLMBoardState, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eHLMInternalState, 2, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boHLMCommState, 3, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMLBBase, 4, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMLBBase, 5, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMLBSIG, 6, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMLBSIG, 7, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct2
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct2(uint8 ucValue1, uint8 ucValue2, uint8 ucValue3, uint8 ucValue4, uint8 ucValue5, uint8 ucValue6, uint8 ucValue7, uint8 ucValue8).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct2(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct2(1,2,3,4,5,6,7,8);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMHB, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMHB, 2, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMDRL, 3, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMDRL, 4, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMPOS, 5, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMPOS, 6, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMTI, 7, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMTI, 8, == );
}

//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct3
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct3(uint8 ucValue1, uint8 ucValue2, uint8 ucValue3, uint8 ucValue4, uint8 ucValue5, uint8 ucValue6, uint8 ucValue7, uint8 ucValue8).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct3(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct3(1,2,3,4,5,6,7,8);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMCL, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMCL, 2, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMCeremony, 3, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boStateHLMFAN, 4, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eFaultHLMFAN, 5, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.usValueVerHLM, 6, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eStatusVerHLM, 7, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.boSPStateVerHLM, 8, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct4
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct4(uint8 ucValue1, uint8 ucValue2).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct4(void)
{
  SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct4(1,2);
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.eErrVerHLM, 1, == );
  AL_UNITTEST_CHECK(sHlmStatesInfo_Swc1.ucSupplyVoltageHLM, 2, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrepRxForwardPrepare_HLM_R_STATES_Info
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrepRxForwardPrepare_HLM_R_STATES_Info(SigPrep1_EnumErrorIndicationType eErr).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrepRxForwardPrepare_HLM_R_STATES_Info(void)
{
  msg_HLM_R_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrepRxForwardPrepare_HLM_R_STATES_Info(eSigPrep1ErrIndRteTimeout);

  msg_HLM_R_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrepRxForwardPrepare_HLM_R_STATES_Info(eSigPrep1ErrIndRteCrc);

  msg_HLM_R_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrepRxForwardPrepare_HLM_R_STATES_Info(eSigPrep1ErrIndRteAliveCounter);

  msg_HLM_R_STATES_Info.quality.state = eSigPrep1PduState_Failed;
  SigPrepRxForwardPrepare_HLM_R_STATES_Info(eSigPrep1ErrNone);

  msg_HLM_R_STATES_Info.quality.state = eSigPrep1PduState_PreFailed;
  SigPrepRxForwardPrepare_HLM_R_STATES_Info(eSigPrep1ErrNone);
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1RxProcessMsg_HLM_R_STATES_Info
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1RxProcessMsg_HLM_R_STATES_Info().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1RxProcessMsg_HLM_R_STATES_Info(void)
{
  sHLMRSTATESInfo.HLM_R_Internal_State = 1;
  GetHLM_R_STATES_InfoResult = SigPrep1RxProcessMsg_HLM_R_STATES_Info();
  AL_UNITTEST_CHECK(msg_HLM_R_STATES_Info.data.sig_HLM_R_Internal_State.value, sHLMRSTATESInfo.HLM_R_Internal_State, == );
  AL_UNITTEST_CHECK(GetHLM_R_STATES_InfoResult, RTE_E_OK, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Rx_HLM_R_STATES_Info_SetQty
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Rx_HLM_R_STATES_Info_SetQty(tibfQtyStsBits tieQty).
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Rx_HLM_R_STATES_Info_SetQty(void)
{
  SigPrep1Rx_HLM_R_STATES_Info_SetQty(eSigPrep1PduState_Passed);
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmRStatesInfo.boE2eRes,0, == );
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmRStatesInfo.boTimeout, 0, == );

  SigPrep1Rx_HLM_R_STATES_Info_SetQty(TIMEOUT_ERROR);
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmRStatesInfo.boE2eRes,0, == );
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmRStatesInfo.boTimeout, 1, == );

  SigPrep1Rx_HLM_R_STATES_Info_SetQty(eSigPrep1PduState_Last);
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmRStatesInfo.boE2eRes,1, == );
  AL_UNITTEST_CHECK(sSubCanDiagInfo.sHlmRStatesInfo.boTimeout, 0, == );
}

/* SigPrep1_MsgLightControlCommandTx.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_LightControlCommand_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_LightControlCommand_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_LightControlCommand_Init(void)
{
  SigPrep1Tx_LightControlCommand_Init();
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxLightControlCommand
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxLightControlCommand().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxLightControlCommand(void)
{
  sClamp2Light_LightControlCommand.boLowBeamCmdLeft = 1;
  sClamp2Light_LightControlCommand.boLowBeamCmdRight = 2;
  sClamp2Light_LightControlCommand.boCornerLightCmdLeft = 4;
  sClamp2Light_LightControlCommand.boCornerLightCmdRight = 5;
  SigPrep1_Can1TxLightControlCommand();
  AL_UNITTEST_CHECK(sLightControlCommand.LowBeamCmd_Left, 1, == );
  AL_UNITTEST_CHECK(sLightControlCommand.LowBeamCmd_Right, 2, == );
  AL_UNITTEST_CHECK(sLightControlCommand.CornerLightCmd_Left, 4, == );
  AL_UNITTEST_CHECK(sLightControlCommand.CornerLightCmd_Right, 5, == );

}

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

/* SigPrep1_MsgMatrixHBCommandTx.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_MatrixHBCommand_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_MatrixHBCommand_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_MatrixHBCommand_Init(void)
{
  SigPrep1Tx_MatrixHBCommand_Init();
  AL_UNITTEST_CHECK(sClamp2Light_MatrixHBCommand.boMatrixHBCmdValid,0, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxMatrixHBCommand
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxMatrixHBCommand().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxMatrixHBCommand(void)
{
  sClamp2Light_MatrixHBCommand.boMatrixHBCmdValid = 1;
  sClamp2Light_MatrixHBCommand.ucRightMatrixHBSegment12 = 2;
  SigPrep1_Can1TxMatrixHBCommand();
  AL_UNITTEST_CHECK(sMatrixHBCommand.MatrixHBCmd_Valid, sClamp2Light_MatrixHBCommand.boMatrixHBCmdValid, == );
  AL_UNITTEST_CHECK(sMatrixHBCommand.RightMatrixHBSegment12, sClamp2Light_MatrixHBCommand.ucRightMatrixHBSegment12, == );
}

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

/* SigPrep1_MsgVehicleInfoTx.c */
//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1Tx_VehicleInfo_Init
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1Tx_VehicleInfo_Init().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1Tx_VehicleInfo_Init(void)
{
  SigPrep1Tx_VehicleInfo_Init();
  AL_UNITTEST_CHECK(sGeneralInfo.sMileage.ulValue,0xFFFFFF, == );
  AL_UNITTEST_CHECK(sGlobalTime.sAbsoluteTime.ucYear,0xFF, == );
  AL_UNITTEST_CHECK(sGlobalTime.sAbsoluteTime.ucMonth,0xF, == );
  AL_UNITTEST_CHECK(sGlobalTime.sAbsoluteTime.ucHour,0x1F, == );
}


//-----------------------------------------------------------------------------
/// \Test Case : Mt_SigPrep1_Can1TxVehicleInfo
///
/// \Test Case Description
///    - Test subject:
///        Call runnable SigPrep1_Can1TxVehicleInfo().
///        No requirement for this release
///
///    - Test Design Technique: ET (Exploratory Testing)
///
///    - Preconditions: none
///
///    - Expected test results:
///        - No requirement for this release
///
//-----------------------------------------------------------------------------
void Mt_SigPrep1_Can1TxVehicleInfo(void)
{
  sPlsr_VehicleInfo.boCeremonyCmdEnable = 1;
  sGeneralInfo.sPowerMode.eStatus = 1;
  SigPrep1_Can1TxVehicleInfo();
  AL_UNITTEST_CHECK(sVehicleInfo.PowerState, 4, == );
  AL_UNITTEST_CHECK(sVehicleInfo.CeremonyCmd_Enable, sPlsr_VehicleInfo.boCeremonyCmdEnable, == );

  sGeneralInfo.sPowerMode.eStatus = 0;
  SigPrep1_Can1TxVehicleInfo();
  AL_UNITTEST_CHECK(sVehicleInfo.PowerState, 0, == );
  AL_UNITTEST_CHECK(sVehicleInfo.CeremonyCmd_Enable, sPlsr_VehicleInfo.boCeremonyCmdEnable, == );

  sGeneralInfo.sPowerMode.eStatus = 3;
  SigPrep1_Can1TxVehicleInfo();
  AL_UNITTEST_CHECK(sVehicleInfo.PowerState, 3, == );
  AL_UNITTEST_CHECK(sVehicleInfo.CeremonyCmd_Enable, sPlsr_VehicleInfo.boCeremonyCmdEnable, == );
}

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

void ALUnitTest_AddTests(void)
{
   /*SigPrep1.c*/
   ALUnitTest_AddFunction("Mt_RTE_Can1HLMLStatesInfoMsg", Mt_RTE_Can1HLMLStatesInfoMsg);
   ALUnitTest_AddFunction("Mt_RTE_Can1HLMRStatesInfoMsg", Mt_RTE_Can1HLMRStatesInfoMsg);
   ALUnitTest_AddFunction("Mt_RTE_Can1AfsCommandMsg", Mt_RTE_Can1AfsCommandMsg);
   ALUnitTest_AddFunction("Mt_RTE_Can1MatrixHBCommandMsg", Mt_RTE_Can1MatrixHBCommandMsg);
   ALUnitTest_AddFunction("Mt_RTE_Can1LightControlCommandMsg", Mt_RTE_Can1LightControlCommandMsg);
   ALUnitTest_AddFunction("Mt_RTE_Can1VehicleInfoMsg", Mt_RTE_Can1VehicleInfoMsg);
   ALUnitTest_AddFunction("Mt_RTE_Can1CeremonyCmdLeft1Msg", Mt_RTE_Can1CeremonyCmdLeft1Msg);
   ALUnitTest_AddFunction("Mt_RTE_Can1CeremonyCmdRight1Msg", Mt_RTE_Can1CeremonyCmdRight1Msg);
   ALUnitTest_AddFunction("Mt_RTE_Can1CeremonyCmdLeft2Msg", Mt_RTE_Can1CeremonyCmdLeft2Msg);
   ALUnitTest_AddFunction("Mt_RTE_Can1CeremonyCmdRight2Msg", Mt_RTE_Can1CeremonyCmdRight2Msg);
   ALUnitTest_AddFunction("Mt_RTE_riSigPrep1Init", Mt_RTE_riSigPrep1Init);
   ALUnitTest_AddFunction("Mt_RTE_rpCan1Tx10ms", Mt_RTE_rpCan1Tx10ms);
   ALUnitTest_AddFunction("Mt_SigPrep1_Init", Mt_SigPrep1_Init);

   /*SigPrep1_Common.c*/
   ALUnitTest_AddFunction("Mt_SigPrep1_divAndRoundClosest", Mt_SigPrep1_divAndRoundClosest);
   ALUnitTest_AddFunction("Mt_SigPrep1CheckRteAndSignalSetQuality", Mt_SigPrep1CheckRteAndSignalSetQuality);
   ALUnitTest_AddFunction("Mt_SigPrep1CheckRteAndusSignalSetQuality", Mt_SigPrep1CheckRteAndusSignalSetQuality);
   ALUnitTest_AddFunction("Mt_SigPrep1_MemSet", Mt_SigPrep1_MemSet);


  /*SigPrep1Rx.c*/
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_initCounterMonitor", Mt_SigPrep1Rx_initCounterMonitor);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_initTimerMonitor", Mt_SigPrep1Rx_initTimerMonitor);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_initPduQualityE2E", Mt_SigPrep1Rx_initPduQualityE2E);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_HandleSignalQualitySuccess", Mt_SigPrep1Rx_HandleSignalQualitySuccess);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_HandleSignalQualityFail", Mt_SigPrep1Rx_HandleSignalQualityFail);
   ALUnitTest_AddFunction("Mt_SigPrep1Rx_HandlePduQualityE2ESuccess", Mt_SigPrep1Rx_HandlePduQualityE2ESuccess);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_HandlePduQualityCounterMonitorSuccess", Mt_SigPrep1Rx_HandlePduQualityCounterMonitorSuccess);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_HandlePduQualityCounterMonitorFail", Mt_SigPrep1Rx_HandlePduQualityCounterMonitorFail);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_HandlePduQualityE2EFail", Mt_SigPrep1Rx_HandlePduQualityE2EFail);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_GetE2E_ErrorIndication", Mt_SigPrep1Rx_GetE2E_ErrorIndication);

  /* SigPrep1_MsgAFSCommandTx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_AFSCommand_Init", Mt_SigPrep1Tx_AFSCommand_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxAFSCommand", Mt_SigPrep1_Can1TxAFSCommand);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetAfsCommandFaultErrorSts", Mt_SigPrep1_GetAfsCommandFaultErrorSts);

  /* SigPrep1_MsgCeremonyCmdLeft1Tx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_CeremonyCmdLeft1_Init", Mt_SigPrep1Tx_CeremonyCmdLeft1_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxCeremonyCmdLeft1", Mt_SigPrep1_Can1TxCeremonyCmdLeft1);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetCeremonyCmdLeft1FaultErrorSts", Mt_SigPrep1_GetCeremonyCmdLeft1FaultErrorSts);

  /* SigPrep1_MsgCeremonyCmdLeft2Tx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_CeremonyCmdLeft2_Init", Mt_SigPrep1Tx_CeremonyCmdLeft2_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxCeremonyCmdLeft2", Mt_SigPrep1_Can1TxCeremonyCmdLeft2);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetCeremonyCmdLeft2FaultErrorSts", Mt_SigPrep1_GetCeremonyCmdLeft2FaultErrorSts);

  /* SigPrep1_MsgCeremonyCmdRight1Tx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_CeremonyCmdRight1_Init", Mt_SigPrep1Tx_CeremonyCmdRight1_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxCeremonyCmdRight1", Mt_SigPrep1_Can1TxCeremonyCmdRight1);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetCeremonyCmdRight1FaultErrorSts", Mt_SigPrep1_GetCeremonyCmdRight1FaultErrorSts);

  /* SigPrep1_MsgCeremonyCmdRight2Tx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_CeremonyCmdRight2_Init", Mt_SigPrep1Tx_CeremonyCmdRight2_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxCeremonyCmdRight2", Mt_SigPrep1_Can1TxCeremonyCmdRight2);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetCeremonyCmdRight2FaultErrorSts", Mt_SigPrep1_GetCeremonyCmdRight2FaultErrorSts);

  /* SigPrep1_MsgHLMLStatesInfo.c */
  ALUnitTest_AddFunction("Mt_Can1HLMLStatesInfoMsg", Mt_Can1HLMLStatesInfoMsg);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1HLMLStatesInfoMsg", Mt_SigPrep1_Can1HLMLStatesInfoMsg);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1HLMLStatesInfoMsgFail", Mt_SigPrep1_Can1HLMLStatesInfoMsgFail);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLMLSTATESInfo_Init", Mt_SigPrep1Rx_MsgHLMLSTATESInfo_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_initSignalData_HLMLStatesInfo", Mt_SigPrep1_initSignalData_HLMLStatesInfo);
  ALUnitTest_AddFunction("Mt_SigPrep1RxForwardToSwc_HLMLStatesInfo", Mt_SigPrep1RxForwardToSwc_HLMLStatesInfo);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct1", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct1);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct2", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct2);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct3", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct3);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct4", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMLStatesInfoFct4);
  ALUnitTest_AddFunction("Mt_SigPrep1RxForwardPrepare_HLM_L_STATES_Info", Mt_SigPrep1RxForwardPrepare_HLM_L_STATES_Info);
  ALUnitTest_AddFunction("Mt_SigPrep1RxProcessMsg_HLM_L_STATES_Info", Mt_SigPrep1RxProcessMsg_HLM_L_STATES_Info);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_HLM_L_STATES_Info_SetQty", Mt_SigPrep1Rx_HLM_L_STATES_Info_SetQty);

  /* SigPrep1_MsgHLMRStatesInfo.c */
  ALUnitTest_AddFunction("Mt_Can1HLMRStatesInfoMsg", Mt_Can1HLMRStatesInfoMsg);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1HLMRStatesInfoMsg", Mt_SigPrep1_Can1HLMRStatesInfoMsg);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1HLMRStatesInfoMsgFail", Mt_SigPrep1_Can1HLMRStatesInfoMsgFail);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLMRSTATESInfo_Init", Mt_SigPrep1Rx_MsgHLMRSTATESInfo_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_initSignalData_HLMRStatesInfo", Mt_SigPrep1_initSignalData_HLMRStatesInfo);
  ALUnitTest_AddFunction("Mt_SigPrep1RxForwardToSwc_HLMRStatesInfo", Mt_SigPrep1RxForwardToSwc_HLMRStatesInfo);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct1", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct1);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct2", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct2);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct3", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct3);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct4", Mt_SigPrep1Rx_MsgHLM_ForwardPrepare_HLMRStatesInfoFct4);
  ALUnitTest_AddFunction("Mt_SigPrepRxForwardPrepare_HLM_R_STATES_Info", Mt_SigPrepRxForwardPrepare_HLM_R_STATES_Info);
  ALUnitTest_AddFunction("Mt_SigPrep1RxProcessMsg_HLM_R_STATES_Info", Mt_SigPrep1RxProcessMsg_HLM_R_STATES_Info);
  ALUnitTest_AddFunction("Mt_SigPrep1Rx_HLM_R_STATES_Info_SetQty", Mt_SigPrep1Rx_HLM_R_STATES_Info_SetQty);

  /* SigPrep1_MsgLightControlCommandTx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_LightControlCommand_Init", Mt_SigPrep1Tx_LightControlCommand_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxLightControlCommand", Mt_SigPrep1_Can1TxLightControlCommand);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetLightControlCommandFaultErrorSts", Mt_SigPrep1_GetLightControlCommandFaultErrorSts);

  /* SigPrep1_MsgMatrixHBCommandTx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_MatrixHBCommand_Init", Mt_SigPrep1Tx_MatrixHBCommand_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxMatrixHBCommand", Mt_SigPrep1_Can1TxMatrixHBCommand);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetMatrixHBCommandFaultErrorSts", Mt_SigPrep1_GetMatrixHBCommandFaultErrorSts);

  /* SigPrep1_MsgVehicleInfoTx.c */
  ALUnitTest_AddFunction("Mt_SigPrep1Tx_VehicleInfo_Init", Mt_SigPrep1Tx_VehicleInfo_Init);
  ALUnitTest_AddFunction("Mt_SigPrep1_Can1TxVehicleInfo", Mt_SigPrep1_Can1TxVehicleInfo);
  ALUnitTest_AddFunction("Mt_SigPrep1_GetVehicleInfoFaultErrorSts", Mt_SigPrep1_GetVehicleInfoFaultErrorSts);

}