Add GPC TTCN-3 library (cdd2cf4a) · Commits · TTCN-3 Libraries / LibIts

ttcn/Rtcmem/LibItsRtcmem_Functions.ttcn

0 → 100644

+342 −0

Original line number	Original line	Diff line number	Diff line
			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

ttcn/Rtcmem/LibItsRtcmem_Pics.ttcn

0 → 100644

+24 −0

Original line number	Original line	Diff line number	Diff line
			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

ttcn/Rtcmem/LibItsRtcmem_Pixits.ttcn

0 → 100644

+3 −0

Original line number	Original line	Diff line number	Diff line
			module LibItsRtcmem_Pixits {

			} // End of module LibItsRtcmem_Pixits

ttcn/Rtcmem/LibItsRtcmem_Templates.ttcn

0 → 100644

+240 −0

Original line number	Original line	Diff line number	Diff line
			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 := *
			}

			} // End of group rtcmemTemplatesRecv

			} // End of module LibItsRtcmem_Templates

ttcn/Rtcmem/LibItsRtcmem_TestSystem.ttcn

0 → 100644

+126 −0

File added.

Preview size limit exceeded, changes collapsed.

Admin message