Commit cdd2cf4a authored by Yann Garcia's avatar Yann Garcia
Browse files

Add GPC TTCN-3 library

parent 5eeb619d
module LibItsRtcmem_Functions {
// LibCommon
import from LibCommon_Sync all;
import from LibCommon_Time all;
import from LibCommon_VerdictControl all;
// LibIts
import from ITS_Container language "ASN.1:1997" all;
import from RTCMEM_PDU_Descriptions language "ASN.1:1997" all;
// LibItsCommon
import from LibItsCommon_TypesAndValues all;
import from LibItsCommon_Templates all;
import from LibItsCommon_Functions all;
import from LibItsCommon_Pixits all;
// LibItsRtcmem
import from LibItsRtcmem_TestSystem all;
import from LibItsRtcmem_TypesAndValues all;
import from LibItsRtcmem_Templates all;
import from LibItsRtcmem_Pics all;
import from LibItsRtcmem_Pixits all;
group utFuntions {
/**
* @desc Requests to bring the IUT in an initial state
* @param p_init The initialisation to trigger.
*/
function f_utInitializeIut(template (value) UtRtcmemInitialize p_init) runs on ItsRtcmem {
//deactivate rtcmemPort default alts
vc_rtcmemDefaultActive := false;
utPort.send(p_init);
tc_wait.start;
alt {
[] utPort.receive(UtRtcmemResults: { utRtcmemInitializeResult := true }) {
tc_wait.stop;
log("*** " & testcasename() & ": INFO: IUT initialized ***");
}
[] tc_wait.timeout {
log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
}
//deactivate rtcmemPort default alts
vc_rtcmemDefaultActive := true;
}
/**
* @desc Triggers an event from the application layer
* @param p_event The event to trigger.
*/
function f_utTriggerEvent(
in template (value) UtRtcmemTrigger p_event
) runs on ItsRtcmem {
//deactivate rtcmemPort default alts
vc_rtcmemDefaultActive := false;
utPort.send ( p_event );
tc_wait.start;
alt {
[] utPort.receive ( UtRtcmemResults: { utRtcmemTriggerResult := true }) {
tc_wait.stop;
}
[] utPort.receive ( UtRtcmemResults: { utRtcmemTriggerResult := false }) {
tc_wait.stop;
f_selfOrClientSyncAndVerdict("SREM Trigger failed", e_error);
}
[] tc_wait.timeout {
log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
[else] { // Shortcut defaults
//f_sleep(0.050); // 50 ms
repeat;
}
}
return;
}
/**
* @desc Updates an event from the application layer
* @param p_event The event to trigger.
*/
function f_utUpdateEvent(
in template (value) UtRtcmemUpdate p_event
) runs on ItsRtcmem {
utPort.send ( p_event );
tc_wait.start;
alt {
[] utPort.receive ( UtRtcmemResults: { utRtcmemUpdateResult := true }) {
tc_wait.stop;
}
[] utPort.receive ( UtRtcmemResults: { utRtcmemUpdateResult := false }) {
tc_wait.stop;
f_selfOrClientSyncAndVerdict("SREM Update failed", e_error);
}
[] tc_wait.timeout {
log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
}
//activate rtcmemPort default alts
vc_rtcmemDefaultActive := true;
return;
}
} // End of group utFuntions
group adapterControl {
/**
* @desc Initialise secure mode if required
*/
function f_initialiseSecuredMode(
in charstring p_certificateId := PX_CERT_FOR_TS
) runs on ItsRtcmem {
if (PICS_IS_IUT_SECURED == true) {
if(e_success != f_acTriggerSecEvent(m_acEnableSecurity(p_certificateId))) {
log("*** INFO: TEST CASE NOW STOPPING ITSELF! ***");
stop;
}
}
} // End of function f_initialiseSecuredMode()
function f_uninitialiseSecuredMode() runs on ItsRtcmem {
if (PICS_IS_IUT_SECURED == true) {
f_acTriggerSecEvent(m_acDisableSecurity);
}
} // End of function f_initialiseSecuredMode()
/**
* @desc Triggers event in the test system adaptation.
* @param p_event The event to trigger
* @return FncRetCode
*/
function f_acTriggerSecEvent(template (value) AcSecPrimitive p_event) runs on ItsRtcmem return FncRetCode {
var FncRetCode v_ret := e_success;
acPort.send(p_event);
tc_ac.start;
alt {
[] acPort.receive(m_acSecResponseSuccess) {
tc_ac.stop;
}
[] acPort.receive {
tc_ac.stop;
log("*** " & __SCOPE__ & ": ERROR: Received unexpected message ***");
f_selfOrClientSyncAndVerdict("error", e_error);
}
[] tc_ac.timeout {
log("*** " & __SCOPE__ & ": ERROR: Timeout while waiting for adapter control event result ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
}
return v_ret;
}
} // End of group adapterControl
group altsteps {
/**
* @desc Default handling cf01 de-initialisation.
*/
altstep a_cf01Down() runs on ItsRtcmem {
[] a_shutdown() {
f_poDefault();
f_cfDown();
log("*** a_cf01Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
stop;
}
}
/**
* @desc The base default.
*/
altstep a_default() runs on ItsRtcmem {
[vc_rtcmemDefaultActive] rtcmemPort.receive(mw_rtcmemInd(mw_rtcmemPdu(mw_defaultRtcmem))) {
log("*** " & testcasename() & ": INFO: SREMM received in default ***");
vc_rtcmemReceived := true;
repeat;
}
[vc_rtcmemDefaultActive] rtcmemPort.receive {
log("*** " & testcasename() & ": ERROR: Received an unexpected message ***");
f_selfOrClientSyncAndVerdict("error", e_error);
}
[] any timer.timeout {
log("*** " & testcasename() & ": INCONC: Timeout while awaiting the reception of a message ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
[] a_shutdown() {
f_poDefault();
f_cfDown();
log("*** " & testcasename() & ": INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
stop;
}
}
/**
* @desc The default for handling upper tester messages.
*/
altstep a_utDefault() runs on ItsRtcmem {
var UtRtcmemEventInd v_rtcmemevent;
[] utPort.receive(UtRtcmemEventInd:?) -> value v_rtcmemevent {
//store every upper tester indication received
vc_utRtcmemEvents[lengthof(vc_utRtcmemEvents)] := v_rtcmemevent;
repeat;
}
[] utPort.receive {
log("*** " & testcasename() & ": INFO: Received unhandled/unknown UT message from IUT ***");
repeat;
}
}
} // End of group altsteps
group rtcmemSsemConfigurationFunctions {
/**
* @desc Setups default configuration
* @param p_certificateId The certificate identifier the TA shall use in case of secured IUT
*/
function f_cfUp(
in charstring p_certificateId := PX_CERT_FOR_TS
) runs on ItsRtcmem system ItsRtcmemSystem {
map(self:acPort, system:acPort);
map(self:utPort, system:utPort);
map(self:rtcmemPort, system:rtcmemPort);
// Connect
f_connect4SelfOrClientSync();
activate(a_cf01Down());
// Initialise secured mode
f_initialiseSecuredMode(p_certificateId);
//Initialze the IUT
f_prInitialState();
} // End of f_cfUp
/**
* @desc Deletes default configuration
*/
function f_cfDown() runs on ItsRtcmem system ItsRtcmemSystem {
// Initialise secured mode
f_uninitialiseSecuredMode();
unmap(self:utPort, system:utPort);
unmap(self:acPort, system:acPort);
unmap(self:rtcmemPort, system:rtcmemPort);
f_disconnect4SelfOrClientSync();
} // End of f_cfDown
} // End of of rtcmemSsemConfigurationFunctions
group preambles {
/**
* @desc The default preamble.
*/
function f_prDefault() runs on ItsRtcmem {
vc_default := activate(a_default());
activate(a_utDefault());
}
/**
* @desc Brings the IUT into an initial state.
* @return FncRetCode
*/
function f_prInitialState() runs on ItsRtcmem return FncRetCode {
var FncRetCode v_ret := e_success;
f_utInitializeIut(m_rtcmemInitialize);
f_prDefault();
return v_ret;
}
} // End of group preambles
group postambles {
/**
* @desc The default postamble.
*/
function f_poDefault() runs on ItsRtcmem {
//empty
}
} // End of group postambles
group sendFunctions {
} // End of group sendFunctions
group receiveFunctions {
/**
* @desc Awaits a SREM and returns it
* @param p_rcvMsg The expected message to be received.
* @param p_rcvdMsg The received message - OUT.
*/
function f_awaitRtcmeMessage(
in template (present) RtcmemInd p_rcvMsg,
out RtcmemInd p_rcvdMsg
) runs on ItsRtcmem {
tc_ac.start;
alt {
[] rtcmemPort.receive(p_rcvMsg) -> value p_rcvdMsg {
tc_ac.stop;
}
[] tc_ac.timeout {
log("*** " & testcasename() & ": INFO: Timeout while awaiting the reception of a message ***");
f_selfOrClientSyncAndVerdict("error", e_timeout);
}
}
}
} // End of group receiveFunctions
} // End of module LibItsRtcmem_Functions
module LibItsRtcmem_Pics {
// LibCommon
import from LibCommon_BasicTypesAndValues all;
/**
* @desc Is the IUT running in secured mode?
* @see ETSI TS 103 191-1 Table A.1
*/
modulepar boolean PICS_IS_IUT_SECURED := false;
/**
* @desc Support for RTCMEM generation
* @see ETSI TS 103 191-1 Table A.5
*/
modulepar boolean PICS_RTCMEM_GENERATION := true;
/**
* @desc Support for RTCMEM reception
* @see ETSI TS 103 191-1 Table A.5
*/
modulepar boolean PICS_RTCMEM_RECEPTION := true;
} // End of module LibItsRtcmem_Pics
module LibItsRtcmem_Pixits {
} // End of module LibItsRtcmem_Pixits
module LibItsRtcmem_Templates {
// LibCommon
import from LibCommon_BasicTypesAndValues all;
import from LibCommon_DataStrings all;
// LibIts
import from ITS_Container language "ASN.1:1997" all;
import from RTCMEM_PDU_Descriptions language "ASN.1:1997" all;
import from DSRC language "ASN.1:1997" all;
// LibItsCommon
import from LibItsCommon_TypesAndValues all;
import from LibItsCommon_Functions all;
import from LibItsCommon_ASN1_NamedNumbers all;
// LibItsRtcmemSsem
import from LibItsRtcmem_TestSystem all;
import from LibItsRtcmem_TypesAndValues all;
import from LibItsRtcmem_Pixits all;
group primitivesTemplates {
/**
* @desc Send template for RTCMEM Message (RtcmemSsemPort Primitive)
* @param p_rtcmemMsg The RTCMEM Message to be sent
*/
template (value) RtcmemReq m_rtcmemReq(
in template (value) RTCMEM p_rtcmemMsg
) := {
msgOut := p_rtcmemMsg
}
/**
* @desc Receive template for RTCMEM Message (RtcmemSsemPort Primitive)
* @param p_rtcmemMsg The expected RTCMEM Message
*/
template (present) RtcmemInd mw_rtcmemInd(
template (present) RTCMEM p_rtcmemMsg
) := {
msgIn := p_rtcmemMsg,
gnNextHeader := *,
gnHeaderType := *,
gnHeaderSubtype := *,
gnLifetime := *,
gnTrafficClass := *,
btpDestinationPort := *,
btpInfo := *,
ssp := *,
its_aid := *
}
/**
* @desc Receive template for RTCMEM Message (RtcmemSsemPort Primitive)
* @param p_rtcmemMsg The expected RTCMEM Message
* @param p_gnNextHeader GN next header value
* @param p_gnHeaderType GN header type value
* @param p_gnHeaderSubtype GN header subtype value
* @param p_gnLifetime GN packet lifetime value (ms)
* @param p_gnTrafficClass GN traffic class value
*/
template (present) RtcmemInd mw_rtcmemIndWithGnParameters(
template (present) RTCMEM p_rtcmemMsg,
in template UInt8 p_gnNextHeader := *,
in template UInt8 p_gnHeaderType := *,
in template UInt8 p_gnHeaderSubtype := *,
in template UInt32 p_gnLifetime := *,
in template UInt8 p_gnTrafficClass := *
) modifies mw_rtcmemInd := {
gnNextHeader := p_gnNextHeader,
gnHeaderType := p_gnHeaderType,
gnHeaderSubtype := p_gnHeaderSubtype,
gnLifetime := p_gnLifetime,
gnTrafficClass := p_gnTrafficClass
}
/**
* @desc Receive template for RTCMEM Message (RtcmemSsemPort Primitive)
* @param p_rtcmemMsg Expected RTCMEM Message
* @param p_btpDestinationPort BTP destination port value
* @param p_btpInfo BTP destination port info value (if BTP-B) or BTP source port value (if BTP-A)
*/
template (present) RtcmemInd mw_rtcmemIndWithBtpParameters(
template (present) RTCMEM p_rtcmemMsg,
template UInt16 p_btpDestinationPort := *,
template UInt16 p_btpInfo := *
) modifies mw_rtcmemInd := {
btpDestinationPort := p_btpDestinationPort,
btpInfo := p_btpInfo
};
/**
* @desc Receive template for RTCMEM Message (RtcmemSsemPort Primitive)
* @param p_rtcmemMsg The expected RTCMEM Message
* @param p_ssp SSP value
* @param p_its_aid ITS-AID value
*/
template (present) RtcmemInd mw_rtcmemIndWithSecurityParameters(
template (present) RTCMEM p_rtcmemMsg,
template Bit256 p_ssp := *,
template UInt32 p_its_aid := *
) modifies mw_rtcmemInd := {
ssp := p_ssp,
its_aid := p_its_aid
}
}
group utPrimitives {
/**
* @desc Send template for Upper Tester event initialization
* @member hashedId8 In case of secured mode set, hashedId8 indicate which certificate the IUT shall use
*/
template (value) UtRtcmemInitialize m_rtcmemInitialize := {
hashedId8 := '0000000000000000'O
}
/**
* @desc Send template for Upper Tester Trigger event
*/
template (omit) UtRtcmemTrigger m_utTriggerEvent(
in MsgCount p_msgCnt,
in RTCM_Revision p_rev := rtcmRev3,
in RTCMmessageList p_msgs,
in template (omit) MinuteOfTheYear p_timeStamp := omit,
in template (omit) FullPositionVector p_anchorPoint := omit,
in template (omit) RTCMheader p_rtcmHeader := omit
) := {
msgCnt := p_msgCnt,
rev := p_rev,
msgs := p_msgs,
timeStamp := p_timeStamp,
anchorPoint := p_anchorPoint,
rtcmHeader := p_rtcmHeader
}
}
group rtcmemPduTemplates {
/**
* @desc Send template for RTCMEM PDU
* @param p_map The RTCMEM Message
*/
template (value) RTCMEM m_rtcmemPdu(
in template (value) RTCMcorrections p_rtcmc
) := {
header := m_itsPduHeader( - , - ,LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_rtcem_),
rtcmc := p_rtcmc
}
/**
* @desc Receive template for RTCMEM PDU
* @param p_rtcmc The RTCMEM Message
*/
template (present) RTCMEM mw_rtcmemPdu(
template (present) RTCMcorrections p_rtcmc := ?
) := {
header := mw_itsPduHeaderRtcmem,
rtcmc := p_rtcmc
}
} // End of group rtcmemPduTemplates
group headerTemplates {
/**
* @desc Default send template for ITS PDU header
* @param p_stationID The source station ID (Default: test system station id)
* @param p_protocolVersion The protocol version (Default: current RTCMEM protocol version)
* @param p_messageID The message Id (Default: RTCMEM id)
*/
template (value) ItsPduHeader m_itsPduHeader(
in template (value) StationID p_stationID := f_getTsStationId(),
in template (value) ItsPduHeader.protocolVersion p_protocolVersion := LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_protocolVersion_currentVersion_,
in template (value) ItsPduHeader.messageID p_messageID
) := {
protocolVersion := p_protocolVersion,
messageID := p_messageID,
stationID := p_stationID
}
/**
* @desc Default receive template for ITS PDU header
* @param p_stationID The expected station id (Default: any)
* @param p_protocolVersion The expected protocol version (Default: current RTCMEM protocol version)
* @param p_messageID The expected message id (Default: RTCMEM message id)
*/
template ItsPduHeader mw_itsPduHeader(
template (present) StationID p_stationID := ?,
template (present) ItsPduHeader.protocolVersion p_protocolVersion := LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_protocolVersion_currentVersion_,
template (present) ItsPduHeader.messageID p_messageID := ?
) := {
protocolVersion := p_protocolVersion,
messageID := p_messageID,
stationID := p_stationID
}
/**
* @desc Default receive template for ITS PDU header
* @param p_stationID The expected station id (Default: any)
* @param p_protocolVersion The expected protocol version (Default: current RTCMEM protocol version)
* @param p_messageID The expected message id (Default: SREM id)
*/
template ItsPduHeader mw_itsPduHeaderRtcmem(
template (present) StationID p_stationID := ?,
template (present) ItsPduHeader.protocolVersion p_protocolVersion := LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_protocolVersion_currentVersion_,
template (present) ItsPduHeader.messageID p_messageID := LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_srem_
) := {
protocolVersion := p_protocolVersion,
messageID := p_messageID,
stationID := p_stationID
}
/**
* @desc Default receive template for the station id
*/
template (present) StationID mw_anyStationId := ?;
} // End of group headerTemplates
group rtcmemTemplatesRecv {
/**
* @desc Receive template for RTCMEM Message
*/
template (present) RTCMcorrections mw_defaultRtcmem := {
msgCnt := ?,
rev := ?,
timeStamp := *,
anchorPoint := *,
rtcmHeader := *,
msgs := ?,
regional := *
}