LibItsGeoNetworking_Functions.ttcn

    v_return.longitude := v_return.longitude + p_longitudeFactor * v_distanceUnit;
    v_return.timestamp_ := f_computeGnTimestamp();
    v_return.pai := int2bit(1,1);
            
      return v_return;
    }
        
    /**
     * @desc    Add a geoArea in geoArea table
     * @param   p_geoAreaTable  GeoArea table to be updated
     * @param   p_areaKey       Reference key of the added geoArea
     * @param   p_geoArea       Added geoArea
     */
    function f_addArea(
                       inout GeoAreaTable p_geoAreaTable,
                       in charstring p_areaKey,
                       in GeoArea p_geoArea
                       ) {
      p_geoAreaTable[lengthof(p_geoAreaTable)] := {
      key := p_areaKey,
      geoArea := p_geoArea
      };
    }
        
    /**
     * @desc    Get the geoArea corresponding to a key
     * @param   p_areaName   Reference key of the searched geoArea
     * @return  GeoArea - The serached geoArea
     */
    function f_getArea(
                       in charstring p_areaName
                       ) runs on ItsGeoNetworking
    return GeoArea {
      var GeoArea v_return;
      var integer i := 0;
            
      for (i:=0; i<lengthof(vc_areaTable); i:=i+1) {
        if (vc_areaTable[i].key == p_areaName) {
        v_return := vc_areaTable[i].geoArea;
        }
      }
            
      return v_return;
    }
        
    /**
     * @desc    Get the geoBroadcastArea corresponding to a key
     * @param   p_areaName   Reference key of the searched geoBroadcastArea
     * @return  GeoBroadcastArea - The serached geoBroadcastArea
     */
    function f_getGeoBroadcastArea(in charstring p_areaName) runs on ItsGeoNetworking
    return GeoBroadcastArea {
      return f_geoArea2GeoBroadcastArea(f_getArea(p_areaName));
    }
        
    /**
     * @desc    Get the GeoAnycastArea corresponding to a key
     * @param   p_areaName   Reference key of the searched GeoAnycastArea
     * @return  GeoAnycastArea - The serached GeoAnycastArea
     */
    function f_getGeoAnycastArea(in charstring p_areaName) runs on ItsGeoNetworking
    return GeoAnycastArea {
      return f_geoArea2GeoAnycastArea(f_getArea(p_areaName));
    }
        
    /**
     * @desc    Convert GeoArea type to GeoBroadcastArea
     * @param   p_area  GeoArea to be converted
     * @return  GeoBroadcastArea
     */
    function f_geoArea2GeoBroadcastArea(GeoArea p_area)
    return GeoBroadcastArea {
      var GeoBroadcastArea v_broadcastArea;
            
      if (p_area.shape == e_geoCircle) {
      v_broadcastArea.geoBroadcastSubType := e_geoBroadcastCircle;
      }
      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;
            
      [vc_gnDefaultActive] a_receiveLsRequest(
                                              ?, ?, v_longPosVectorIut
                                              ) {
        repeat;
      }
      /* FIXME To be reviewed [vc_gnDefaultActive] geoNetworkingPort.receive(
                                                     mw_geoNwInd(
                                                                 mw_geoNwSecPdu(
                                                                                mw_securedMessage_CAMs,
                                                                                ?
                                                                                ))) {
        // Skip CAM messages
        log("*** a_default: WARNING: Skip secured CAM messages ***");
        repeat;
      }*/
      [vc_gnDefaultActive] 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 {
            
      [vc_gnDefaultActive] a_receiveLsRequestAndReply(
                                                      ?, f_getPosition(vc_componentName).gnAddr.mid,
                f_getPosition(vc_componentName)//,
                //Spirent removed f_getPosition(vc_componentName)
                                                      ) {
        repeat;
      }
      [vc_componentName == c_compNodeB and vc_gnDefaultActive] a_receiveLsRequestAndReply(
                                                                                          ?, f_getPosition(c_compNodeA).gnAddr.mid,
                f_getPosition(c_compNodeA)//,
                //Spirent removed f_getPosition(vc_componentName)
                                                                                          ) {
        repeat;
      }
      [] a_default() {
      }
    }
        
    /**
     * @desc The default for handling upper tester messages.
     */
    altstep a_utDefault() runs on ItsBaseGeoNetworking {
      var UtGnEventInd v_ind;
      [vc_utDefaultActive] utPort.receive(UtGnEventInd:?) -> value v_ind {
        //store every upper tester indication received
        vc_utInds[lengthof(vc_utInds)] := v_ind;
        repeat;
      }
      [vc_utDefaultActive] 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 {
                
        [vc_gnDefaultActive] 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 {
                
        [vc_gnDefaultActive] a_receiveGeoUnicast(p_destinationShortPosVec, ?) {}
      }
            
      /**
       * @desc Receive any GeoUnicast packet
       */
      altstep a_receiveAnyGeoUnicast() runs on ItsGeoNetworking {
                
        [vc_gnDefaultActive] 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 {
                
        [vc_gnDefaultActive] 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 {
                
        [vc_gnDefaultActive] 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 {
                
        [vc_gnDefaultActive] 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 {
                
        [vc_gnDefaultActive] 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 {
                
        [vc_gnDefaultActive] 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_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 {
                
        [vc_gnDefaultActive] 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_mid 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;
        
        [vc_gnDefaultActive] 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;
                
        [vc_gnDefaultActive] a_receiveLsRequest(?, ?, v_reqSrcPosVector) {}
      }
            
      /**
       * @desc Receive any Location Service Reply
       */
      altstep a_receiveAnyLsReply() runs on ItsGeoNetworking {
        [vc_gnDefaultActive] 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
       */
      altstep a_receiveLsRequestAndReply(
                                         in template (present) UInt16 p_reqSeqNumber,
                                         in template (value) GN_Address.mid p_mid,
                in template (value) LongPosVector p_repSrcPosVector
                                         ) runs on ItsGeoNetworking {
        var LongPosVector v_repDstPosVector;
                
        [vc_gnDefaultActive] a_receiveLsRequest(p_reqSeqNumber, p_mid, v_repDstPosVector) {
          f_sendGeoNetMessage(valueof(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();
      f_sleep(0.5);
    }
        
    /**
     * @desc Brings the IUT into an initial state.
     * @remark Component variable vc_hashedId8ToBeUsed shall be set with the IUT certificate to be used
     */
    function f_initialState(Scenario p_scenario := e_staticPosition) runs on ItsBaseGeoNetworking {
            
      if (PICS_GN_SECURITY) {
        var Oct8 v_hashedId8ToBeUsed := f_setupIutCertificate(vc_hashedId8ToBeUsed);
        if (oct2int(v_hashedId8ToBeUsed) == 0) {
        v_hashedId8ToBeUsed := 'FFFFFFFFFFFFFFFF'O; // Reset to unknown value, the IUT will use its own certificates
        }
        f_utInitializeIut(m_secGnInitialize(v_hashedId8ToBeUsed));
      } // else, default behavior
      else {
        f_utInitializeIut(m_gnInitialize);
      }
      f_sleep(PX_NEIGHBOUR_DISCOVERY_DELAY);
      
      f_acLoadScenario(p_scenario);
      f_acStartScenario();
            f_acAwaitTimeInRunningScenario(f_getTimeForGpsFix());
    }
        
    /**
     * @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) {//Spirent removed, 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(
                          valueof(
                                  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 {
      f_acStopScenario();
    }
        
    /**
     * @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
            
            // Load certificates
            if (PICS_GN_SECURITY) {
                if( not f_loadCertificates(PX_IUT_SEC_CONFIG_NAME) ) {
                    return e_error;
                }
                
                // Initialize vc_location
                f_setGenerationLocation(
                    f_getTsLatitude(),
                    f_getTsLongitude()
                );
                return f_acTriggerSecEvent(m_acEnableSecurity(cc_taCert_A));
            }
      return f_acTriggerSecEvent(m_acEnableSecurity(PX_CERT_FOR_TS));
    }
        
    /**
     * @desc    Triggers test adapter to disable security support
     * @return  FncRetCode
     */
    function f_acDisableSecurity() runs on ItsBaseGeoNetworking return FncRetCode {
            
      f_unloadCertificates();
            
      return f_acTriggerSecEvent(m_acDisableSecurity);
            
    }
        
    /**
     * @desc    Triggers event in the test system adaptation.
     * @param   p_event The event to trigger
     * @return  FncRetCode
     */
    function f_acTriggerSecEvent(
                                 in template (value) AcSecPrimitive p_event
                                 ) runs on ItsBaseGeoNetworking 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;
    }
        
    /**
     * @desc    Triggers event in the test system adaptation.
     * @param   p_event The event to trigger
     * @return  FncRetCode
     */
    function f_acTriggerGnssEvent(template (value) AcGnssPrimitive p_event) runs on ItsBaseGeoNetworking return FncRetCode {
      var FncRetCode v_ret := e_success;
            
      acPort.send(p_event);
      tc_ac.start;
      alt {
        [] acPort.receive(m_acGnssResponseSuccess) {
          tc_ac.stop;
        }
        [] acPort.receive {
          tc_ac.stop;
          log("*** f_acTriggerGnssEvent: ERROR: Received unexpected message ***");
          f_selfOrClientSyncAndVerdict("error", e_error);
        }
        [] tc_ac.timeout {
          log("*** f_acTriggerGnssEvent: ERROR: Timeout while waiting for adapter control event result ***");
          f_selfOrClientSyncAndVerdict("error", e_timeout);
        }
      }
            
      return v_ret;
    }
        
    /**
     * @desc    Loads the given scenario
     * 
     * @param   p_scenario   The scenario to load.
     */
    function f_acLoadScenario(Scenario p_scenario) runs on ItsBaseGeoNetworking {
            
      if (PX_GNSS_SCENARIO_SUPPORT==true) {
        f_acTriggerGnssEvent(m_loadScenario(p_scenario));
      }
    } // end f_acLoadScenario
        
    /**
     * @desc    Starts a loaded scenario
     */
    function f_acStartScenario() runs on ItsBaseGeoNetworking {
            
      if (PX_GNSS_SCENARIO_SUPPORT==true) {
        f_acTriggerGnssEvent(m_startScenario);
      vc_scenarioStarted := true;
      }
    } // end f_acStartScenario
        
    /**
     * @desc    Stops a loaded scenario
     */
    function f_acStopScenario() runs on ItsBaseGeoNetworking {
            
      if (PX_GNSS_SCENARIO_SUPPORT==true and vc_scenarioStarted==true) {
        f_acTriggerGnssEvent(m_stopScenario);
      vc_scenarioStarted := false;
      }
    } // end f_acStopScenario
        
        function f_acAwaitTimeInRunningScenario(integer p_time) runs on ItsBaseGeoNetworking return FncRetCode {
            var FncRetCode v_ret := e_success;
            
            if (PX_GNSS_SCENARIO_SUPPORT==true and vc_scenarioStarted==true) {
                f_acTriggerGnssEvent(m_timeInRunningScenario(p_time));
                
                tc_ac.start(int2float(p_time)*1.1);
                alt {
                    [] acPort.receive(m_acGnssTimeReachedSuccess) {
                        tc_ac.stop;
                    }
                    [] acPort.receive(m_acGnssTimeReachedError) {
                        tc_ac.stop;
                        log("*** " & __SCOPE__ & ": ERROR: Received unexpected message ***");
                        f_selfOrClientSyncAndVerdict("error", e_error);
                    }
                    [] tc_ac.timeout {
                        log("*** " & __SCOPE__ & ": ERROR: Timeout while waiting for time reached indication ***");
                        f_selfOrClientSyncAndVerdict("error", e_timeout);
                    }
                }
                
            }
            return v_ret;
        } // end f_acAwaitTimeInRunningScenario
        
  } // 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;
    }