LibItsGeoNetworking_Functions.ttcn

            else if (p_area.shape == e_geoRect) {
                v_broadcastArea.geoBroadcastSubType := e_geoBroadcastRect;
            }
            else if (p_area.shape == e_geoElip) {
                v_broadcastArea.geoBroadcastSubType := e_geoBroadcastElip;
            }
            else {
                v_broadcastArea.geoBroadcastSubType := e_reserved;
            }
            
            v_broadcastArea.geoBroadcastArea := p_area.area;
            
            return v_broadcastArea;
        }
        
        /**
         * @desc    Convert GeoArea type to GeoAnycastArea
         * @param   p_area  GeoArea to be converted
         * @return  GeoAnycastArea
         */
        function f_geoArea2GeoAnycastArea(GeoArea p_area)
        return GeoAnycastArea {
            var GeoAnycastArea v_anycastArea;
            
            if (p_area.shape == e_geoCircle) {
                v_anycastArea.geoAnycastSubType := e_geoAnycastCircle;
            }
            else if (p_area.shape == e_geoRect) {
                v_anycastArea.geoAnycastSubType := e_geoAnycastRect;
            }
            else if (p_area.shape == e_geoElip) {
                v_anycastArea.geoAnycastSubType := e_geoAnycastElip;
            }
            else {
                v_anycastArea.geoAnycastSubType := e_reserved;
            }
            
            v_anycastArea.geoAnycastArea := p_area.area;
            
            return v_anycastArea;
        }
        
        /**
         * @desc    Compute a square geoArea
         * @param   p_centerLongPosVector   Center point of the square area
         * @param   p_distanceA             Width of the square area in meters
         * @return  GeoArea - Computed geoArea
         */
        function f_computeSquareArea(
            in LongPosVector p_centerLongPosVector,
            in UInt16 p_distanceA
        ) return GeoArea {
            
            var GeoArea v_geoArea;
            
            v_geoArea := {
                shape := e_geoRect,
                area := {
                    geoAreaPosLatitude := p_centerLongPosVector.latitude,
                    geoAreaPosLongitude := p_centerLongPosVector.longitude,
                    distanceA := p_distanceA,
                    distanceB := p_distanceA,
                    angle := 0
                }
            }
            
            return v_geoArea;
        }
        
        /**
         * @desc    Compute a circular geoArea
         * @param   p_centerLongPosVector   Center point of the square area
         * @param   p_distanceA             Radius of the square area in meters
         * @return  GeoArea - Computed geoArea
         */
        function f_computeCircularArea(
            in LongPosVector p_centerLongPosVector,
            in UInt16 p_distanceA
        ) return GeoArea {
                
            var GeoArea v_geoArea;
            
            v_geoArea := {
                shape := e_geoCircle,
                area := {
                    geoAreaPosLatitude := p_centerLongPosVector.latitude,
                    geoAreaPosLongitude := p_centerLongPosVector.longitude,
                    distanceA := p_distanceA,
                    distanceB := 0,
                    angle := 0
                }
            }
            
            return v_geoArea;
        }
        
        /**
         * @desc    Compute radius of an circular area
         * @param   p_squareMeters  Square meters of an circular area
         * @return  Computed radius in meters
         * @see     fx_computeRadiusFromCircularArea
         */
        function f_radiusFromCircularArea(
            in float p_squareMeters
        ) return float {
         
//            log("*** f_distance: INFO: calling fx_computeRadiusFromCircularArea() ***");
            return fx_computeRadiusFromCircularArea(p_squareMeters);
        }
        
        /**
         * @desc    Compute distance between two points
         * @param   p_pointA    First point
         * @param   p_pointB    Second point
         * @return  Computed distance in meters
         * @see     fx_computeDistance
         */
        function f_distance(
            in LongPosVector p_pointA,
            in LongPosVector p_pointB
        ) return float {
         
//            log("*** f_distance: INFO: calling fx_computeDistance() ***");
            return fx_computeDistance(p_pointA.latitude, p_pointA.longitude, p_pointB.latitude, p_pointB.longitude);
        }
        
    } // end geoPositionFunctions
    
    group geoAltsteps {
        
        /**
         * @desc The base default.
         */
        altstep a_default() runs on ItsGeoNetworking {
            
            var LongPosVector v_longPosVectorIut;
            
            [] a_receiveLsRequest(
                ?, ?, v_longPosVectorIut
               ) {
                repeat;
            }
            [] geoNetworkingPort.receive(
                mw_geoNwInd(
                    mw_geoNwSecPdu(
                        mdw_securedMessage_CAMs,
                        ?
            ))) {
                // Skip CAM messages
                repeat;
            }
            [] geoNetworkingPort.receive {
                log("*** a_default: WARNING: Received an unexpected message ***");
                repeat;
            }
            [] tc_wait.timeout {
                log("*** a_default: ERROR: Timeout while awaiting reaction of the IUT prior to Upper Tester action ***");
                f_selfOrClientSyncAndVerdict("error", e_timeout);
            }
            [] tc_ac.timeout {
                log("*** a_default: ERROR: Timeout while awaiting the reception of a message ***");
                f_selfOrClientSyncAndVerdict("error", e_timeout);
            }
            [] a_shutdown() {
                log("*** a_default: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }
        
        /**
         * @desc    Neighbour default altstep (answers to LS Requests)
         */
        altstep a_neighbourDefault() runs on ItsGeoNetworking {
            
            [] a_receiveLsRequestAndReply(
                ?, f_getPosition(vc_componentName).gnAddr.mid,
                f_getPosition(vc_componentName),
                f_getPosition(vc_componentName)
               ) {
                repeat;
            }
            [vc_componentName == c_compNodeB] a_receiveLsRequestAndReply(
                ?, f_getPosition(c_compNodeA).gnAddr.mid,
                f_getPosition(c_compNodeA),
                f_getPosition(vc_componentName)
               ) {
                repeat;
            }
            [] a_default() {
            }
        }
        
        /**
         * @desc The default for handling upper tester messages.
         */
        altstep a_utDefault() runs on ItsGeoNetworking {
            var UtGnEventInd v_ind;
            [] utPort.receive(UtGnEventInd:?) -> value v_ind {
                //store every upper tester indication received
                vc_utInds[lengthof(vc_utInds)] := v_ind;
                repeat;
            }
            [] utPort.receive {
                log("*** " & testcasename() & ": INFO: Received unexpected UT message from IUT ***");
                repeat;
            }
        }
        
        /**
         * @desc Default handling cf01 de-initialisation.
         */
        altstep a_cf01Down() runs on ItsGeoNetworking {
            [] a_shutdown() {
                f_poDefault();
                f_cf01Down();
                log("*** a_cf01Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }
        
        /**
         * @desc Default handling cf02 de-initialisation.
         */
        altstep a_cf02Down() runs on ItsMtc {
            [] a_shutdown() {
                f_cf02Down();
                log("*** a_cf02Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }
        
        /**
         * @desc Default handling cf03 de-initialisation.
         */
        altstep a_cf03Down() runs on ItsMtc {
            [] a_shutdown() {
                f_cf03Down();
                log("*** a_cf03Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }
        
        /**
         * @desc Default handling cf04 de-initialisation.
         */
        altstep a_cf04Down() runs on ItsMtc {
            [] a_shutdown() {
                f_cf04Down();
                log("*** a_cf04Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }

        /**
         * @desc Default handling cf05 de-initialisation.
         */
        altstep a_cf05Down() runs on ItsMtc {
            [] a_shutdown() {
                f_cf05Down();
                log("*** a_cf05Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }
        
        /**
         * @desc Default handling cf06 de-initialisation.
         */
        altstep a_cf06Down() runs on ItsMtc {
            [] a_shutdown() {
                f_cf06Down();
                log("*** a_cf06Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }
        
        /**
         * @desc Default handling cf07 de-initialisation.
         */
        altstep a_cf07Down() runs on ItsMtc {
            [] a_shutdown() {
                f_cf07Down();
                log("*** a_cf07Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***");
                stop;
            }
        }        
        group geoGeoUnicastAltsteps {
            
            /**
             * @desc    Receive GeoUnicast packet
             * @param   p_sourceLongPosVec          Expected source position vector
             * @param   p_destinationShortPosVec    Expected destination position vector
             * @param   p_seqNumber                 Expected sequence number
             */
            altstep a_receiveGeoUnicast(
                in template (present) ShortPosVector p_destinationShortPosVec,
                in template (present) UInt16 p_seqNumber
            ) runs on ItsGeoNetworking {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwUnicastPacket(
                    p_destinationShortPosVec,
                    p_seqNumber)))) {
                }
            }
            
            /**
             * @desc    Receive GeoUnicast packet for specific destination
             * @param   p_destinationShortPosVec    Expected destination position vector
             */
            altstep a_receiveGeoUnicastWithDestination(in template (present) ShortPosVector p_destinationShortPosVec) runs on ItsGeoNetworking {
                
                [] a_receiveGeoUnicast(p_destinationShortPosVec, ?) {}
            }
            
            /**
             * @desc Receive any GeoUnicast packet
             */
            altstep a_receiveAnyGeoUnicast() runs on ItsGeoNetworking {
                
                [] a_receiveGeoUnicast(?, ?) {}
            }
            
        } // end geoGeoUnicastAltsteps
        
        group geoGeoBroadcastAltsteps {
            
            /**
             * @desc Receive GeoBroadcast packet
             * @param   p_srcLongPosVec     Expected source position vector
             * @param   p_seqNumber         Expected sequence number
             */
            altstep a_receiveGeoBroadcast(
                in template (present) LongPosVector p_srcLongPosVec,
                in template (present) UInt16 p_seqNumber
            ) runs on ItsGeoNetworking {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacket(
                        p_srcLongPosVec,
                        p_seqNumber
                    )))) {
                }
            }
            
            /**
             * @desc Receive GeoBroadcast packet with specific Area and HopLimit
             * @param   p_srcLongPosVec     Expected source position vector
             * @param   p_seqNumber         Expected sequence number
             * @param   p_broadcastArea     Expected geoBroadcastArea
             * @param   p_routerHopLimit    Expected router hop limit
             * @param   p_maxHopLimit       Expected max hop limit (Default: ?)
             */
            altstep a_receiveGeoBroadcastWithAreaWithHopLimit(
                in template (present) LongPosVector p_srcLongPosVec,
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoBroadcastArea p_broadcastArea,
                in template (present) UInt8 p_routerHopLimit,
                in template (present) UInt8 p_maxHopLimit := ?
            ) runs on ItsGeoNetworking {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithAreaAndHl(
                        p_srcLongPosVec,
                        p_seqNumber,
                        p_broadcastArea,
                        p_maxHopLimit
                      ),
                      -,
                      p_routerHopLimit
                    ))) {
                }
            }
            
            /**
             * @desc Receive GeoBroadcast packet for specific Geobroadcast Area
             * @param   p_srcLongPosVec     Expected source position vector
             * @param   p_seqNumber         Expected sequence number
             * @param   p_broadcastArea     Expected geoBroadcastArea
             */
            altstep a_receiveGeoBroadcastWithArea(
                in template (present) LongPosVector p_srcLongPosVec,
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoBroadcastArea p_broadcastArea
            ) runs on ItsGeoNetworking {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwBroadcastPacketWithArea(
                        p_srcLongPosVec,
                        p_seqNumber,
                        p_broadcastArea
                    )))) {
                }
            }
            
        } // end geoGeoBroadcastAltsteps
        
        group geoGeoAnycastAltsteps {
            
            /**
             * @desc Receive GeoAnycast packet
             * @param   p_srcLongPosVec     Expected source position vector
             * @param   p_senderLongPosVec  Expected sender position vector
             * @param   p_seqNumber         Expected sequence number
             */
            altstep a_receiveGeoAnycast(
                in template (present) LongPosVector p_srcLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) UInt16 p_seqNumber
            ) runs on ItsGeoNetworking {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwAnycastPacket(
                        p_srcLongPosVec,
                        p_seqNumber
                    )))) {
                }
            }
            
            /**
             * @desc Receive GeoAnycast packet with specific Area and HopLimit
             * @param   p_srcLongPosVec     Expected source position vector
             * @param   p_senderLongPosVec  Expected sender position vector
             * @param   p_seqNumber         Expected sequence number
             * @param   p_anycastArea       Expected geoAnycastArea
             * @param   p_hopLimit          Expected hop limit
             * @param   p_maxHopLimit       Expected max hop limit (Default: ?)
             */
            altstep a_receiveGeoAnycastWithAreaWithHopLimit(
                in template (present) LongPosVector p_srcLongPosVec,
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoAnycastArea p_anycastArea,
                in template (present) UInt8 p_hopLimit,
                in template (present) UInt8 p_maxHopLimit := ?
            ) runs on ItsGeoNetworking {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwAnycastPacketWithArea(
                        p_srcLongPosVec,
                        p_seqNumber,
                        p_anycastArea
                      ),
                      -,
                      p_hopLimit
                    ))) {
                }
            }
            
            /**
             * @desc Receive GeoAnycast packet for specific GeoAnycast Area
             * @param   p_srcLongPosVec     Expected source position vector
             * @param   p_senderLongPosVec  Expected sender position vector
             * @param   p_seqNumber         Expected sequence number
             * @param   p_anycastArea       Expected geoAnycastArea
             */
            altstep a_receiveGeoAnycastWithArea(
                in template (present) LongPosVector p_srcLongPosVec,
                in template (present) UInt16 p_seqNumber,
                in template (present) GeoAnycastArea p_anycastArea
            ) runs on ItsGeoNetworking {
                
                [] geoNetworkingPort.receive(mw_geoNwInd(mw_geoNwPdu(mw_geoNwAnycastPacketWithArea(
                        p_srcLongPosVec,
                        p_seqNumber,
                        p_anycastArea
                    )))) {
                }
            }
            
        } // end geoGeoAnycastAltsteps
        
        group geoLocationServiceAltsteps {
            
            /**
             * @desc    Receive Location Service Request
             * @param   p_seqNumber Expected sequence number of the received LS Request
             * @param   p_gnAddress GN address expected in received LS Request
             * @param   p_reqSrcPosVector Expected source position vector of the received LS Request
             */
            altstep a_receiveLsRequest(
                in template (present) UInt16 p_seqNumber,
                in template (present) GN_Address.mid p_mid,
                out LongPosVector p_reqSrcPosVector
            ) runs on ItsGeoNetworking {
                var GeoNetworkingInd v_msg;
                
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwLsRequestPacket(
                                p_seqNumber,
                                p_mid
                            )
                        )
                    )
                ) -> value v_msg {
                    p_reqSrcPosVector := valueof(v_msg.msgIn.gnPacket.packet.extendedHeader.lsRequestHeader.srcPosVector);
                }
            }
            
            /**
             * @desc Receive any Location Service Request
             */
            altstep a_receiveAnyLsRequest() runs on ItsGeoNetworking {
                var LongPosVector v_reqSrcPosVector;
                
                [] a_receiveLsRequest(?, ?, v_reqSrcPosVector) {}
            }
            
            /**
             * @desc Receive any Location Service Reply
             */
            altstep a_receiveAnyLsReply() runs on ItsGeoNetworking {
                [] geoNetworkingPort.receive( mw_geoNwInd( mw_geoNwPdu( mw_geoNwLsReplyPacket(?, ?) ))) {
                    //ignore and repeat
                    repeat;
                }
            }
            
            /**
             * @desc Receive Location Service Request and send Location Service Reply
             * @param   p_reqSeqNumber          Expected sequence number of the received LS Request
             * @param   p_gnAddress             GN address expected in received LS Request
             * @param   p_repSrcPosVector       Source position vector of the sent LS Response
             * @param   p_repSenderPosVector    Sender position vector of the sent LS Response
             */
            altstep a_receiveLsRequestAndReply(
                in template (present) UInt16 p_reqSeqNumber,
                in template (value) GN_Address.mid p_mid,
                in template (value) LongPosVector p_repSrcPosVector,
                in template (value) LongPosVector p_repSenderPosVector
            ) runs on ItsGeoNetworking {
                var LongPosVector v_repDstPosVector;
                
                [] a_receiveLsRequest(p_reqSeqNumber, p_mid, v_repDstPosVector) {
                    f_sendGeoNetMessage(m_geoNwReq_linkLayerBroadcast(m_geoNwPdu(
                        m_geoNwLsReplyPacket(
                            p_repSrcPosVector,
                            f_longPosVector2ShortPosVector(v_repDstPosVector),
                            vc_localSeqNumber
                    ))));
                }
            }
          
        } // end geoLocationServiceAltsteps
        
        
    } // end geoAltsteps
    
    group preambles {
        
        /**
         * @desc The default preamble.
         */
        function f_prDefault() runs on ItsGeoNetworking {
            activate(a_default());
            activate(a_utDefault());
        }
        
        /**
         * @desc Preamble for non-neighbour nodes
         */
        function f_prNonNeighbour() runs on ItsGeoNetworking {
            f_prDefault();
        }
        
        /**
         * @desc Preamble for neighbour nodes
         */
        function f_prNeighbour() runs on ItsGeoNetworking {
            f_prDefault();
            f_startBeingNeighbour();
        }
        
        /**
         * @desc Brings the IUT into an initial state.
         */
        function f_initialState() runs on ItsBaseGeoNetworking {
           
            f_utInitializeIut(m_gnInitialize);
        }
        
        /**
         * @desc    Receive and reply to LS Requests
         * @param   p_reqSeqNumber          Expected sequence number of the received LS Request
         * @param   p_gnAddress             GN address expected in received LS Request
         * @param   p_repSrcPosVector       Source position vector of the sent LS Response
         * @param   p_repSenderPosVector    Sender position vector of the sent LS Response
         */
        function f_handleLocationService(
          in template (present) UInt16 p_reqSeqNumber,
          in template (value) GN_Address.mid p_mid,
          in template (value) LongPosVector p_repSrcPosVector,
          in template (value) LongPosVector p_repSenderPosVector
        ) runs on ItsGeoNetworking {
            
            tc_ac.start;
            alt {
                [] a_receiveLsRequestAndReply(p_reqSeqNumber, p_mid, p_repSrcPosVector, p_repSenderPosVector) {
                    tc_ac.stop;
                }
            }
            
        }
        
        /**
         * @desc    Send LS request and receive LS Reply
         * @param   p_reqSrcPosVector   Source position vector of the sent LS Request
         * @param   p_reqSeqNumber      Sequence number of the sent LS Request
         * @param   p_gnAddress         GN address for which the LS Request is sent
         * @param   p_repSrcPosVector   Expected source position vector in received LS Response
         * @return  FncRetCode
         */
        function f_processLocationService(
          in template (value) LongPosVector p_reqSrcPosVector,
          in template (value) UInt16 p_reqSeqNumber,
          in template (value) GN_Address p_gnAddress,
          out LongPosVector p_repSrcPosVector
        ) runs on ItsGeoNetworking return FncRetCode {
            var FncRetCode v_ret := e_error;
            var GeoNetworkingInd v_msg;
            
            f_sendGeoNetMessage(
                m_geoNwReq_linkLayerBroadcast(
                    m_geoNwPdu(
                        m_geoNwLsRequestPacket(
                            p_reqSrcPosVector,
                            p_reqSeqNumber,
                            p_gnAddress
                        )
                    )
                )
            );
            
            tc_ac.start;
            alt {
                [] geoNetworkingPort.receive(
                        mw_geoNwInd(
                            mw_geoNwPdu(
                                mw_geoNwLsReplyPacket(
                                    ?,
                                    mw_shortPosVectorPosition(f_longPosVector2ShortPosVector(valueof(p_reqSrcPosVector)))
                                )
                            )
                        )
                    ) -> value v_msg {
                    tc_ac.stop;
                    p_repSrcPosVector := valueof(v_msg.msgIn.gnPacket.packet.extendedHeader.lsReplyHeader.srcPosVector);
                    v_ret := e_success;
                }
            }
            
            return v_ret;
        }
        
    } // end preambles
    
    group postambles {
        
        /**
         * @desc The default postamble.
         */
        function f_poDefault() runs on ItsGeoNetworking {
            //empty
        }
        
        /**
         * @desc Postamble for neighbour nodes
         */
        function f_poNeighbour() runs on ItsGeoNetworking {
            f_stopBeingNeighbour();
            f_poDefault();
        }
        
    } // end postambles
    
    group adapterControl {
        
        /**
         * @desc    Triggers event in the test system adaptation.
         * @param   p_event The event to trigger
         * @return  FncRetCode
         */
        function f_acTriggerEvent(template (value) AcGnPrimitive p_event) runs on ItsBaseGeoNetworking return FncRetCode {
            var FncRetCode v_ret := e_success;
            
            acPort.send(p_event);
            
            return v_ret;
        }
        
        /**
         * @desc    Get the position vector corresponding to a specific GN address
         * @param   p_gnAddress     GN address for which the search is performed
         * @return  LongPosVector - IUT's position
         */
        function f_acGetLongPosVector(GN_Address p_gnAddress) runs on ItsBaseGeoNetworking return LongPosVector {
            var AcGnResponse v_result;
            
            f_acTriggerEvent(m_getLongPosVector(p_gnAddress));
            tc_ac.start;
            alt {
                [] acPort.receive(mw_getLongPosVectorAny(p_gnAddress)) -> value v_result {
                    tc_ac.stop;
                }
                [] acPort.receive {
                    tc_ac.stop;
                    log("*** f_acGetLongPosVector: ERROR: Received unexpected message ***");
                    f_selfOrClientSyncAndVerdict("error", e_error);
                }
                [] tc_ac.timeout {
                    log("*** f_acGetLongPosVector: ERROR: Timeout while waiting for adapter control event result ***");
                    f_selfOrClientSyncAndVerdict("error", e_timeout);
                }
            }
            
            return v_result.getLongPosVector;
        }
        
        /**
         * @desc    Triggers test adapter to send beacons for multiple neighbours
         * @param   p_numberOfNeighbour Number of neighbours to simulate
         * @return  FncRetCode
         */
        function f_acStartBeaconingMultipleNeighbour(in integer p_numberOfNeighbour) runs on ItsGeoNetworking return FncRetCode {
            
            return f_acTriggerEvent(m_startBeaconingMultipleNeighbour(m_beaconHeader(f_getPosition(vc_componentName)).beaconHeader, p_numberOfNeighbour));
            
        }
        
        /**
         * @desc    Triggers test adapter to enable security support
         * @return  FncRetCode
         */
        function f_acEnableSecurity() runs on ItsBaseGeoNetworking return FncRetCode {
            
            // Local variables
            var template (value) ToBeSignedSecuredMessage v_toBeSignedSecuredMessageDigest;
            var template (value) ToBeSignedSecuredMessage v_toBeSignedSecuredMessageCertificate;
            
            // Load certificates
            f_loadCertificates("cfg01");
            // Initialize vc_location
            f_setGenerationLocation(
                f_getTsLatitude(),
                f_getTsLongitude()
            );
            
            // Build the beacon template
            v_toBeSignedSecuredMessageDigest := f_buildSecuredMessagePayloadToBeSigned();
            v_toBeSignedSecuredMessageCertificate := f_buildSecuredMessagePayloadToBeSigned(true);
            
            return f_acTriggerEvent(
                AcGnPrimitive:{ acEnableSecurity := m_enableSecurity(
                    vc_signingPrivateKey,
                    vc_atCertificate.subject_attributes[0].attribute.key.public_key.eccPoint.x,
                    vc_atCertificate.subject_attributes[0].attribute.key.public_key.eccPoint.y.y,
                    vc_encryptPrivateKey,
                    vc_atCertificate.subject_attributes[1].attribute.key.public_key.aesCcm.eccPoint.x,
                    vc_atCertificate.subject_attributes[1].attribute.key.public_key.aesCcm.eccPoint.y.y,
                    bit2oct(encvalue(v_toBeSignedSecuredMessageDigest)),
                    bit2oct(encvalue(v_toBeSignedSecuredMessageCertificate))
                ) } 
            );
        }
        
        /**
         * @desc    Triggers test adapter to disable security support
         * @return  FncRetCode
         */
        function f_acDisableSecurity() runs on ItsBaseGeoNetworking return FncRetCode {
            
            f_unloadCertificates();
            
            return f_acTriggerEvent(AcGnPrimitive:{ acDisableSecurity := m_disableSecurity } );
            
        }
        
    } // end adapterControl
    
    group commonFunctions {
        
        /**
         * @desc    Gets the value of the lifetime in seconds.
         * @param   p_lifetime Lifetime to be converted
         * @return  Lifetime in seconds
         */
        function f_getLifetimeValue(in Lifetime p_lifetime) runs on ItsGeoNetworking return float {
            var float v_lifetime := 0.0;
          
            select (p_lifetime.ltBase) {
                case (e_50ms) {
                    v_lifetime := int2float(p_lifetime.multiplier) * 0.5;
                }
                case (e_1s) {
                    v_lifetime := int2float(p_lifetime.multiplier) * 1.0;
                }
                case (e_10s) {
                    v_lifetime := int2float(p_lifetime.multiplier) * 10.0;
                }
                case (e_100s) {
                    v_lifetime := int2float(p_lifetime.multiplier) * 100.0;
                }
            }
          
            return v_lifetime;
        }
        
        /**
         * @desc    Computes GN timestamp based on current time
         * @return  Unix-Epoch-Time mod 2^32
         */
        function f_computeGnTimestamp() return UInt32 {
            
            //  Timestamp is 1s older than current time to avoid sending beacons coming from the future (time sync between nodes)
            var UInt32 v_timestamp := fx_computeGnTimestamp() - 1000;
            return v_timestamp;    
        }
        
    } // end commonFunctions
    
    group testerFunctions {
        
        /**
         * @desc    Gets the tester GN local address for a specific node
         * @param   p_node  Simulated node
         * @return  GN address of simulated node
         */
        function f_getTsGnLocalAddress(in charstring p_node) return GN_Address {
            var GN_Address v_gnAddr := valueof(m_dummyGnAddr);
            
            select (p_node) {
                case (c_compNodeA) {
                    v_gnAddr := PX_TS_NODE_A_LOCAL_GN_ADDR;
                }
                case (c_compNodeB) {
                    v_gnAddr := PX_TS_NODE_B_LOCAL_GN_ADDR;
                }
                case (c_compNodeC) {
                    v_gnAddr := PX_TS_NODE_C_LOCAL_GN_ADDR;
                }
                case (c_compNodeD) {
                    v_gnAddr := PX_TS_NODE_D_LOCAL_GN_ADDR;
                }
                case (c_compNodeE) {
                    v_gnAddr := PX_TS_NODE_E_LOCAL_GN_ADDR;
                }
                case (c_compNodeF) {
                    v_gnAddr := PX_TS_NODE_F_LOCAL_GN_ADDR;
                }
                case else {
                    log("*** f_getTsGnLocalAddress: INFO: Unknown component " & p_node & " ***");
                }
            }
            
            return v_gnAddr;
        }
        
        /**
         * @desc    Sends a GeoNetworking message and in case of an included sequence number in the message the
         *          local sequence number will be increased by one.
         * @param   p_geoNetReq The message to send.
         */
        function f_sendGeoNetMessage(in template (value) GeoNetworkingReq p_geoNetReq) runs on ItsGeoNetworking {
            geoNetworkingPort.send(p_geoNetReq);
            if (not (ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.shbHeader)
                    or ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.beaconHeader))) {
                f_setLocalSequenceNumber();
            }
        }
        
        /**
         * @desc    Sends a GeoNetworking message with a payload and in case of an included sequence number in the message the
         *          local sequence number will be increased by one.
         * @param   p_geoNetReq The message to send.
         * @param   p_payload   The payload to include.
         */
        function f_sendGeoNetMessageWithPayload(
            in template (value) GeoNetworkingReq p_geoNetReq,
            in template (value) Payload p_payload
        ) runs on ItsGeoNetworking {
            p_geoNetReq.msgOut.gnPacket.packet.payload := p_payload;
            geoNetworkingPort.send(p_geoNetReq);
            if (not (ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.shbHeader)
                    or ischosen(p_geoNetReq.msgOut.gnPacket.packet.extendedHeader.beaconHeader))) {
                f_setLocalSequenceNumber();
            }
        }
        
        /**
         * @desc    Receive a GeoNetworking message with a payload and in case of an included sequence number in the message the
         *          local sequence number will be increased by one.
         * @param   p_geoNetInd The message to receive.
         * @param   p_payload   The payload to include.
         */
        function f_receiveGeoNetMessageWithPayload(
            in template (present) GeoNetworkingInd p_geoNetInd,
            in template (present) Payload p_payload
        ) return template (present) GeoNetworkingInd {
            var template (present) GeoNetworkingInd v_geoNetInd := p_geoNetInd;
            
            v_geoNetInd.msgIn.gnPacket.packet.payload := p_payload;
            
            return v_geoNetInd;
        }
        
        /**
         * @desc    Sets the value of the sequence number for the next event.
         */
        function f_setLocalSequenceNumber() runs on ItsGeoNetworking {
            vc_localSeqNumber := (vc_localSeqNumber + 1) mod c_uInt16Max;
        }
        
        /**
         * @desc    Creates an initial seqence number
         * @return  Time based initial sequence number (increasing with time)
         */
        function f_getInitialSequenceNumber() return UInt16 {
            
            return (f_computeGnTimestamp() / 1000) mod c_uInt16Max;
        }
        
        /**
         * @desc    Number of messages to be sent
         * @return  Number of messages to be sent
         */
        function f_getMessageCount() return integer {
            return PX_MESSAGE_COUNT;
        }
        
    } // end testerFunctions
    
    group iutFunctions {
        
        /**
         * @desc    Gets the IUT GN local address
         * @return  IUT's GN_Address
         * @see     PICS_GN_LOCAL_GN_ADDR
         */
        function f_getIutGnLocalAddress() return GN_Address {
            
            return PICS_GN_LOCAL_GN_ADDR;
        }
        
        /**
         * @desc    Gets the IUT GN local address configuration method
         * @return  TypeOfAddress - IUT's GN local address configuration method
         * @see     PICS_GN_LOCAL_ADDR_CONF_METHOD
         */
        function f_getIutGnLocalAddressConfigurationMethod() return TypeOfAddress {
            return PICS_GN_LOCAL_ADDR_CONF_METHOD;
        }
        
        /**
         * @desc    Gets the IUT MAc address
         * @return  MacAddress - IUT's MAc Address
         * @see     PICS_IUT_MAC_ADDRESS
         */
        function f_getIutMacAddress() return MacAddress {
            return PICS_IUT_MAC_ADDRESS;
        }
        
        /**
         * @desc    Gets the GeoUnicast forwarding algorithm
         * @return  IUT's GeoUnicast forwarding algorithm
         * @see     PICS_GN_GEOUNICAST_FORWARDING_ALGORITHM
         */
        function f_getGeoUnicastForwardingAlgorithm() return GeoUnicastForwardingAlgorithm {
            return PICS_GN_GEOUNICAST_FORWARDING_ALGORITHM;
        }
        
        /**
         * @desc    Gets the GeoBroadcast forwarding algorithm
         * @return  IUT's GeoBroadcast forwarding algorithm
         * @see     PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM
         */
        function f_getGeoBroadcastForwardingAlgorithm() return GeoBroadcastForwardingAlgorithm {
            return PICS_GN_GEOBROADCAST_FORWARDING_ALGORITHM;
        }
        
        /**
         * @desc    Gets the IUT default hop limit
         * @return  IUT's default hop limit
         * @see     PICS_GN_DEFAULT_HOP_LIMIT
         */
        function f_getDefaultHopLimit() return UInt8 {
            return PICS_GN_DEFAULT_HOP_LIMIT;
        }
        
        /**
         * @desc    Is the ITS-S mobile or stationary?
         * @return  Flags indicating whether the ITS-S is mobile or stationary.
         * @see     PICS_GN_IS_MOBILE
         */
        function f_isMobile() return Bit8 {
            if (PICS_GN_IS_MOBILE) {
              return '10000000'B;
            }
            return '00000000'B;
        }
        
        /**
         * @desc    Gets the LS retransmission timer.. Valid for NetRepInterval = default (cong. ctrl).
         * @return  LS retransmission timer in seconds
         * @see     PICS_GN_LOCATION_SERVICE_RETRANSMIT_TIMER
         */
        function f_getLsRetransmitTimer() return float {