module ItsAutoInterop_TestCases {
    
  // LibCommon
  import from LibCommon_VerdictControl all;
  import from LibCommon_Sync all;
  import from LibCommon_BasicTypesAndValues all;
  import from LibCommon_DataStrings all;
  import from LibCommon_Time all;
    
  // LibIts
  import from ITS_Container language "ASN.1:1997" all;
  import from IEEE1609dot2BaseTypes language "ASN.1:1997" all;
  import from IEEE1609dot2 language "ASN.1:1997" all;
  import from EtsiTs103097Module language "ASN.1:1997" all;
  import from DENM_PDU_Descriptions language "ASN.1:1997" all; // TODO To be removed
    
  // LibItsCommon
  import from LibItsCommon_TestSystem all;
  import from LibItsCommon_Functions all;
  import from LibItsExternal_TypesAndValues all;
  import from LibItsCommon_ASN1_NamedNumbers all;
    
  // LibItsGeoNetworking
  import from LibItsGeoNetworking_TypesAndValues all;
  import from LibItsGeoNetworking_Templates all;
  import from LibItsGeoNetworking_Pixits all;
  import from LibItsGeoNetworking_TestSystem all;
    
  // LibItsDenm
  import from LibItsDenm_Templates all;
    
  // LibItsCam
  import from LibItsCam_Templates all;
    
  // LibItsSecurity
  import from LibItsSecurity_TypesAndValues all;
    
  // AtsInterop
  import from ItsAutoInterop_TypesAndValues all;
  import from ItsAutoInterop_Templates all;
  import from ItsAutoInterop_Functions all;
  import from ItsAutoInterop_Pics all;
  import from ItsAutoInterop_Pixits all;
  import from ItsAutoInterop_TestSystem all;
    
  /**
   * @desc    Verify complete forwarding message scenario (GREEDY, GREEDY, GREEDY) 
   * <pre>
   * Pics Selection: 
   * Config Id: CF-01
   * Initial conditions:
   *  with {
   *      itsGnNonAreaForwardingAlgorithm of EUT1 set to GREEDY
   *      itsGnNonAreaForwardingAlgorithm of EUT2 set to GREEDY
   *      itsGnNonAreaForwardingAlgorithm of EUT3 set to GREEDY
   *      itsGnNonAreaForwardingAlgorithm of EUT4 is SIMPLE
   *  }
   * Expected behaviour:
   *  ensure that {
   *      when {
   *          EUT1 is requested to send DEN message
   *              encapsulated in a GBC packet
   *          containing Basic Header
   *              containing RHL field
   *                  indicating a value > 1
   *          containing DestinationArea
   *              indicating the TARGET_GEOAREA
   *      }
   *      then {
   *          EUT1 sends a GBC packet
   *              containing Basic Header
   *                  containing RHL field
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *                  containing the DEN message
   *              encapsulated in a LL packet
   *                  containing a destination MAC address
   *                      indicating the EUT2 address
   *      }
   *      when {
   *          EUT2 receives the GBC packet from EUT1
   *      }
   *      then {
   *          EUT2 sends a GBC packet
   *              containing Basic Header
   *                  containing RHL field
   *                      indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *                  containing the DEN message
   *              encapsulated in a LL packet
   *                  containing a destination MAC address
   *                      indicating the EUT4 address
   *              and EUT3 does not receive the GBC packet from EUT1
   *      }
   *      when {
   *          EUT4 receives the GBC packet from EUT2
   *              containing Basic Header
   *              containing RHL field
   *                  indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *                  containing the DEN message
   *      }
   *      then {
   *          EUT4 provides the DEN message to upper layers 
   *          and EUT4 sends a GBC packet
   *              containing Basic Header
   *                  containing RHL field
   *                      indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *              containing the DEN message
   *              encapsulated in a LL packet 
   *                  containing a destination MAC address
   *                      indicating broadcast address
   *      }
   *      when {
   *      EUT2 receives the GBC packet from EUT4
   *      }
   *      then {
   *          EUT2 discards the GBC packet
   *      }
   *      when {
   *          EUT3 receives the GBC packet from EUT4
   *      }
   *      then {
   *          EUT3 discards the GBC packet
   *      }
   *  }
   * </pre>
   *
   * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_DENM_MFW_BV_01
   * @reference   ETSI EN 302 636-4-1 Clauses D & E2
   */
  testcase TC_AUTO_IOT_DENM_MFW_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
    var ItsAutoInteropGeonetworking v_eut3 := null;
    var ItsAutoInteropGeonetworking v_eut4 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf01Up(v_eut1, v_eut2, v_eut3, v_eut4);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_DENM_MFW_BV_01_eut1(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_DENM_MFW_BV_01_eut2(v_eut2, PX_EUT2_ID));
    v_eut3.start(f_TC_AUTO_IOT_DENM_MFW_BV_01_eut3(v_eut3, PX_EUT3_ID));
    v_eut4.start(f_TC_AUTO_IOT_DENM_MFW_BV_01_eut4(v_eut4, PX_EUT4_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(4, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf01Down(v_eut1, v_eut2, v_eut3, v_eut4);
        
  } // End of TC_AUTO_IOT_DENM_MFW_BV_01
    
  group g_TC_AUTO_IOT_DENM_MFW_BV_01 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_DENM_MFW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_01_eut1(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      tc_ac.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT1 is requested to send DEN message
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            mw_longPosVector(
                                                                                                                                                             PICS_TARGET_GEOAREA
                                                                                                                                                             ),
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                               )*/)),
                                                                                PX_EUT_DESC[PX_EUT2_ID].ll_mac_address
                                                                                )) { //  Receives the triggered DENM message
          tc_ac.stop;
          log("*** " & testcasename() & ": INFO: EUT1 sends a GBC packet ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: EUT1 does not send the requested DEN message ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT1 shall not receive any more DEN messages
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               ? // FIXME complement(PX_EUT_DESC[p_eut_id].stationId)
                                                                                                                                               )*/)),
                                                                                ?
                                                                                )) { 
          tc_wait.stop;
          log("*** " & testcasename() & ": FAIL: Unexpected DEN message received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, GREEDY) succeed ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_01_eut1
        
    /**
     * @desc    Behavior function for EUT2 (TC_AUTO_IOT_DENM_MFW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_01_eut2(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT2 receives the GBC packet from EUT1
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   mw_longPosVector(
                                                                                                                                    PICS_TARGET_GEOAREA
                                                                                                                                    ),
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?/*mw_denm_stationId(
                                                                                                                      PX_EUT_DESC[PX_EUT1_ID].stationId
                                                                                                                      )*/)))) -> value v_eutGeoNw {
          // Now, we have to check for EUT4 to broadcast the DENM message
          repeat;
        }
        [] eutGeoNetworkingPort.receive( // EUT2 receives the GBC packet from EUT4
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[PX_EUT4_ID].stationId
                                                                                                                                               )*/)),
                                                                                c_llBroadcast
                                                                                )) -> value v_eutGeoNw { 
          tc_wait.stop;
          log("*** " & testcasename() & ": INFO: EUT2 receives the GBC packet from EUT4 ***");
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT2 discards the GBC packet
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": INCONC: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is incomplete ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
      else {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_01_eut2
        
    /**
     * @desc    Behavior function for EUT3 (TC_AUTO_IOT_DENM_MFW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_01_eut3(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT3 receives the GBC packet from EUT4
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?//mw_denm_stationId
                                                                                                                                            )),
                                                                                ?
                                                                                )) -> value v_eutGeoNw { 
          tc_wait.stop;
          log("*** " & testcasename() & ": INFO: EUT3 received DEN message from EUT ", v_eutGeoNw.msg.gnPacket.packet.extendedHeader.tsbHeader.srcPosVector.gnAddr.mid, " ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT3 discards the GBC packet
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": INCONC: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is incomplete ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
      else {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_01_eut3
        
    /**
     * @desc    Behavior function for EUT4 (TC_AUTO_IOT_DENM_MFW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_01_eut4(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT4 receives the GBC packet from EUT2
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            mw_longPosVector(
                                                                                                                                                             PICS_TARGET_GEOAREA
                                                                                                                                                             ),
                                                                                                                                            ?,
                                                                                                                                            e_btpB,
                                                                                                                                            ?//mw_denm_stationId
                                                                                                                                            )),
                                                                                PX_EUT_DESC[p_eut_id].ll_mac_address
                                                                                )) -> value v_eutGeoNw { // Receive a DEN message from EUT2
          tc_wait.stop;
          // Now check that EUT4 brodcasts the DENM message
          log("*** " & testcasename() & ": INFO: EUT4 receives the GBC packet from EUT2 ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT4 provides the DEN message to upper layers 
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
      else {
        log("*** " & testcasename() & ": INCONC: EUT4 does not provide the DEN message to upper layers ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_01_eut4
        
  } // End of group g_TC_AUTO_IOT_DENM_MFW_BV_01
    
    /**
     * @desc    Verify complete forwarding message scenario (GREEDY, GREEDY, CBF) 
     * <pre>
     * Pics Selection: 
     * Config Id: CF-01
     * Initial conditions:
     *  with {
     *      itsGnNonAreaForwardingAlgorithm of EUT1 set to GREEDY
     *      itsGnNonAreaForwardingAlgorithm of EUT2 set to GREEDY
     *      itsGnNonAreaForwardingAlgorithm of EUT3 set to CBF
     *      itsGnNonAreaForwardingAlgorithm of EUT4 is SIMPLE
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          EUT1 is requested to send DEN message
     *              encapsulated in a GBC packet
     *          containing Basic Header
     *              containing RHL field
     *                  indicating a value > 1
     *          containing DestinationArea
     *              indicating the TARGET_GEOAREA
     *      }
     *      then {
     *          EUT1 sends a GBC packet
     *              containing Basic Header
     *                  containing RHL field
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *                  containing the DEN message
     *              encapsulated in a LL packet
     *                  containing a destination MAC address
     *                      indicating the EUT2 address
     *      }
     *      when {
     *          EUT2 receives the GBC packet from EUT1
     *      }
     *      then {
     *          EUT2 sends a GBC packet
     *              containing Basic Header
     *                  containing RHL field
     *                      indicating value decreased by 1
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *                  containing the DEN message
     *              encapsulated in a LL packet
     *                  containing a destination MAC address
     *                      indicating the EUT4 address
     *              and EUT3 does not receive the GBC packet from EUT1
     *      }
     *      when {
     *          EUT4 receives the GBC packet from EUT2
     *              containing Basic Header
     *              containing RHL field
     *                  indicating value decreased by 1
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *                  containing the DEN message
     *      }
     *      then {
     *          EUT4 provides the DEN message to upper layers 
     *          and EUT4 sends a GBC packet
     *              containing Basic Header
     *                  containing RHL field
     *                      indicating value decreased by 1
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *              containing the DEN message
     *              encapsulated in a LL packet 
     *                  containing a destination MAC address
     *                      indicating broadcast address
     *      }
     *      when {
     *      EUT2 receives the GBC packet from EUT4
     *      }
     *      then {
     *          EUT2 discards the GBC packet
     *      }
     *      when {
     *          EUT3 receives the GBC packet from EUT4
     *      }
     *      then {
     *          EUT3 discards the GBC packet
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_DENM_MFW_BV_02
     * @reference   ETSI EN 302 636-4-1 Clauses D & E2
     */
  testcase TC_AUTO_IOT_DENM_MFW_BV_02() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
    var ItsAutoInteropGeonetworking v_eut3 := null;
    var ItsAutoInteropGeonetworking v_eut4 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf01Up(v_eut1, v_eut2, v_eut3, v_eut4);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_DENM_MFW_BV_02_eut1(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_DENM_MFW_BV_02_eut2(v_eut2, PX_EUT2_ID));
    v_eut3.start(f_TC_AUTO_IOT_DENM_MFW_BV_02_eut3(v_eut3, PX_EUT3_ID));
    v_eut4.start(f_TC_AUTO_IOT_DENM_MFW_BV_02_eut4(v_eut4, PX_EUT4_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(4, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf01Down(v_eut1, v_eut2, v_eut3, v_eut4);
        
  } // End of TC_AUTO_IOT_DENM_MFW_BV_02
    
  group g_TC_AUTO_IOT_DENM_MFW_BV_02 {
        
 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_DENM_MFW_BV_02)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_02_eut1(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      tc_ac.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT1 is requested to send DEN message
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            mw_longPosVector(
                                                                                                                                                             PICS_TARGET_GEOAREA
                                                                                                                                                             ),
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                               )*/)),
                                                                                PX_EUT_DESC[PX_EUT2_ID].ll_mac_address
                                                                                )) { //  Receives the triggered DENM message
          tc_ac.stop;
          log("*** " & testcasename() & ": INFO: EUT1 sends a GBC packet ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: EUT1 does not send the requested DEN message ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT1 shall not receive any more DEN messages
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               ? // FIXME complement(PX_EUT_DESC[p_eut_id].stationId)
                                                                                                                                               )*/)),
                                                                                ?
                                                                                )) { 
          tc_wait.stop;
          log("*** " & testcasename() & ": FAIL: Unexpected DEN message received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, CBF) succeed ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_02_eut1
        
    /**
     * @desc    Behavior function for EUT2 (TC_AUTO_IOT_DENM_MFW_BV_02)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_02_eut2(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT2 receives the GBC packet from EUT1
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   mw_longPosVector(
                                                                                                                                    PICS_TARGET_GEOAREA
                                                                                                                                    ),
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?/*mw_denm_stationId(
                                                                                                                      PX_EUT_DESC[PX_EUT1_ID].stationId
                                                                                                                      )*/)))) -> value v_eutGeoNw {
          // Now, we have to check for EUT4 to broadcast the DENM message
          repeat;
        }
        [] eutGeoNetworkingPort.receive( // EUT2 receives the GBC packet from EUT4
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[PX_EUT4_ID].stationId
                                                                                                                                               )*/)),
                                                                                c_llBroadcast
                                                                                )) -> value v_eutGeoNw { 
          tc_wait.stop;
          log("*** " & testcasename() & ": INFO: EUT2 receives the GBC packet from EUT4 ***");
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, GREEDY, CBF) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT2 discards the GBC packet
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": INCONC: Forwarding message scenario (GREEDY, GREEDY, CBF) is incomplete ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
      else {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, CBF) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_02_eut2
        
    /**
     * @desc    Behavior function for EUT3 (TC_AUTO_IOT_DENM_MFW_BV_02)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_02_eut3(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT3 receives the GBC packet from EUT4
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?//mw_denm_stationId
                                                                                                                                            )),
                                                                                ?
                                                                                )) -> value v_eutGeoNw { 
          tc_wait.stop;
          log("*** " & testcasename() & ": INFO: EUT3 received DEN message from EUT ", v_eutGeoNw.msg.gnPacket.packet.extendedHeader.tsbHeader.srcPosVector.gnAddr.mid, " ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, GREEDY, CBF) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT3 discards the GBC packet
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": INCONC: Forwarding message scenario (GREEDY, GREEDY, CBF) is incomplete ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
      else {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, CBF) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_02_eut3
        
    /**
     * @desc    Behavior function for EUT4 (TC_AUTO_IOT_DENM_MFW_BV_02)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_02_eut4(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT4 receives the GBC packet from EUT2
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            mw_longPosVector(
                                                                                                                                                             PICS_TARGET_GEOAREA
                                                                                                                                                             ),
                                                                                                                                            ?,
                                                                                                                                            e_btpB,
                                                                                                                                            ?//mw_denm_stationId
                                                                                                                                            )),
                                                                                PX_EUT_DESC[p_eut_id].ll_mac_address
                                                                                )) -> value v_eutGeoNw { // Receive a DEN message from EUT2
          tc_wait.stop;
          // Now check that EUT4 brodcasts the DENM message
          log("*** " & testcasename() & ": INFO: EUT4 receives the GBC packet from EUT2 ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, GREEDY, GREEDY) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT4 provides the DEN message to upper layers 
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, GREEDY, CBF) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
      else {
        log("*** " & testcasename() & ": INCONC: EUT4 does not provide the DEN message to upper layers ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_02_eut4
        
  } // End of group g_TC_AUTO_IOT_DENM_MFW_BV_02
    
  /**
   * @desc    Verify complete forwarding message scenario (GREEDY, CBF, GREEDY) 
   * <pre>
   * Pics Selection: 
   * Config Id: CF-01
   * Initial conditions:
   *  with {
   *      itsGnNonAreaForwardingAlgorithm of EUT1 set to GREEDY
   *      itsGnNonAreaForwardingAlgorithm of EUT2 set to CBF
   *      itsGnNonAreaForwardingAlgorithm of EUT3 set to GREEDY
   *      itsGnNonAreaForwardingAlgorithm of EUT4 is SIMPLE
   *  }
   * Expected behaviour:
   *  ensure that {
   *      when {
   *          EUT1 is requested to send DEN message
   *              encapsulated in a GBC packet
   *          containing Basic Header
   *              containing RHL field
   *                  indicating a value > 1
   *          containing DestinationArea
   *              indicating the TARGET_GEOAREA
   *      }
   *      then {
   *          EUT1 sends a GBC packet
   *              containing Basic Header
   *                  containing RHL field
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *                  containing the DEN message
   *              encapsulated in a LL packet
   *                  containing a destination MAC address
   *                      indicating the EUT2 address
   *      }
   *      when {
   *          EUT2 receives the GBC packet from EUT1
   *      }
   *      then {
   *          EUT2 sends a GBC packet
   *              containing Basic Header
   *                  containing RHL field
   *                      indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *                  containing the DEN message
   *              encapsulated in a LL packet
   *                  containing a destination MAC address
   *                      indicating broadcast address
   *      }
   *      when {
   *          EUT1 receives the GBC packet from EUT2
   *      }
   *      then {
   *          EUT1 discards the GBC packet
   *      }
   *      when {
   *          EUT4 receives the GBC packet from EUT2
   *              containing Basic Header
   *              containing RHL field
   *                  indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *                  containing the DEN message
   *      }
   *      then {
   *          EUT4 provides the DEN message to upper layers 
   *          and EUT4 sends a GBC packet
   *              containing Basic Header
   *                  containing RHL field
   *                      indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *              containing the DEN message
   *              encapsulated in a LL packet 
   *                  containing a destination MAC address
   *                      indicating broadcast address
   *      }
   *      when {
   *          EUT3 received the GBC packet from EUT2
   *              containing Basic Header
   *              containing RHL field
   *                  indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *                  containing the DEN message
   *      }
   *      then {
   *          EUT3 sends a GBC packet
   *              containing Basic Header
   *                  containing RHL field
   *                      indicating value decreased by 1
   *              containing DestinationArea
   *                  indicating the TARGET_GEOAREA
   *              containing Payload
   *              containing the DEN message
   *              encapsulated in a LL packet 
   *                  containing a destination MAC address
   *                      indicating EUT4 address
   *      }
   *      when {
   *          EUT4 receives the GBC packet from EUT3
   *      }
   *      then {
   *          EUT4 discards the GBC packet (duplicated)
   *      }
   *      when {
   *          EUT3 receives the GBC packet from EUT4
   *      }
   *      then {
   *          EUT3 discards the GBC packet
   *      }
   *      when {
   *          EUT2 receives the GBC packet from EUT4
   *      }
   *      then {
   *          EUT2 discards the GBC packet
   *      }
   *  }
   * </pre>
   *
   * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_DENM_MFW_BV_03
   * @reference   ETSI EN 302 636-4-1 Clauses D & E2
   */
  testcase TC_AUTO_IOT_DENM_MFW_BV_03() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
    var ItsAutoInteropGeonetworking v_eut3 := null;
    var ItsAutoInteropGeonetworking v_eut4 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf01Up(v_eut1, v_eut2, v_eut3, v_eut4);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_DENM_MFW_BV_03_eut1(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_DENM_MFW_BV_03_eut2(v_eut2, PX_EUT2_ID));
    v_eut3.start(f_TC_AUTO_IOT_DENM_MFW_BV_03_eut3(v_eut3, PX_EUT3_ID));
    v_eut4.start(f_TC_AUTO_IOT_DENM_MFW_BV_03_eut4(v_eut4, PX_EUT4_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(4, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf01Down(v_eut1, v_eut2, v_eut3, v_eut4);
        
  } // End of TC_AUTO_IOT_DENM_MFW_BV_03
    
  group g_TC_AUTO_IOT_DENM_MFW_BV_03 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_DENM_MFW_BV_03)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_03_eut1(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      tc_ac.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT1 is requested to send DEN message
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            mw_longPosVector(
                                                                                                                                                             PICS_TARGET_GEOAREA
                                                                                                                                                             ),
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                               )*/)),
                                                                                PX_EUT_DESC[PX_EUT2_ID].ll_mac_address
                                                                                )) { //  Receives the triggered DENM message
          tc_ac.stop;
          log("*** " & testcasename() & ": INFO: EUT1 sends a GBC packet ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: EUT1 does not send the requested DEN message ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT1 receives the GBC packet from EUT2
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               ? // FIXME complement(PX_EUT_DESC[p_eut_id].stationId)
                                                                                                                                               )*/)),
                                                                                c_llBroadcast
                                                                                )) { 
          tc_wait.stop;
          log("*** " & testcasename() & ": Info: EUT1 receives the GBC packet from EUT2 ***");
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": INFO: Forwarding message scenario (GREEDY, CBF, GREEDY) succeed ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
      // EUT1 discards the GBC packet
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": INCONC: Forwarding message scenario (GREEDY, CBF, GREEDY) is incomplete ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
      else {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, CBF, GREEDY) succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_03_eut1
        
    /**
     * @desc    Behavior function for EUT2 (TC_AUTO_IOT_DENM_MFW_BV_03)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_03_eut2(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT2 receives the GBC packet from EUT1
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   mw_longPosVector(
                                                                                                                                    PICS_TARGET_GEOAREA
                                                                                                                                    ),
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?/*mw_denm_stationId(
                                                                                                                      PX_EUT_DESC[PX_EUT1_ID].stationId
                                                                                                                      )*/)))) -> value v_eutGeoNw {
          // Now, we have to check for EUT4 to broadcast the DENM message
          repeat;
        }
        [] eutGeoNetworkingPort.receive( // EUT2 receives the GBC packet from EUT4
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[PX_EUT4_ID].stationId
                                                                                                                                               )*/)),
                                                                                c_llBroadcast
                                                                                )) -> value v_eutGeoNw { 
          tc_wait.stop;
          log("*** " & testcasename() & ": INFO: EUT2 receives the GBC packet from EUT4 ***");
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, CBF, GREEDY) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT2 discards the GBC packet
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": INCONC: Forwarding message scenario (GREEDY, CBF, GREEDY) is incomplete ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
      else {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, CBF, GREEDY) succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_03_eut2
        
    /**
     * @desc    Behavior function for EUT3 (TC_AUTO_IOT_DENM_MFW_BV_03)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_03_eut3(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT3 receives the GBC packet from EUT2
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               ? // FIXME complement(PX_EUT_DESC[p_eut_id].stationId)
                                                                                                                                               )*/)),
                                                                                c_llBroadcast
                                                                                )) { 
          log("*** " & testcasename() & ": Info: EUT3 receives the GBC packet from EUT2 ***");
          repeat;
        }
        [] eutGeoNetworkingPort.receive( // EUT3 receives the GBC packet from EUT4
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?//mw_denm_stationId
                                                                                                                                            )),
                                                                                ?
                                                                                )) -> value v_eutGeoNw { 
          tc_wait.stop;
          log("*** " & testcasename() & ": INFO: EUT3 received DEN message from EUT ", v_eutGeoNw.msg.gnPacket.packet.extendedHeader.tsbHeader.srcPosVector.gnAddr.mid, " ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, CBF, GREEDY) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT3 discards the GBC packet
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": INCONC: Forwarding message scenario (GREEDY, CBF, GREEDY) is incomplete ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
      else {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, CBF, GREEDY) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_03_eut3
        
    /**
     * @desc    Behavior function for EUT4 (TC_AUTO_IOT_DENM_MFW_BV_03)
     */
    function f_TC_AUTO_IOT_DENM_MFW_BV_03_eut4(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT4 receives the GBC packet from EUT2
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            mw_longPosVector(
                                                                                                                                                             PICS_TARGET_GEOAREA
                                                                                                                                                             ),
                                                                                                                                            ?,
                                                                                                                                            e_btpB,
                                                                                                                                            ?//mw_denm_stationId
                                                                                                                                            )),
                                                                                PX_EUT_DESC[p_eut_id].ll_mac_address
                                                                                )) -> value v_eutGeoNw { // Receive a DEN message from EUT2
          tc_wait.stop;
          // Now check that EUT4 brodcasts the DENM message
          log("*** " & testcasename() & ": INFO: EUT4 receives the GBC packet from EUT2 ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Forwarding message scenario (GREEDY, CBF, GREEDY) is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
      // EUT4 provides the DEN message to upper layers 
      f_sleep(PX_TNOAC);
      if(0 < lengthof(vc_utInds)) {
        log("*** " & testcasename() & ": PASS: Forwarding message scenario (GREEDY, CBF, GREEDY) is succeed ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
      }
      else {
        log("*** " & testcasename() & ": INCONC: EUT4 does not provide the DEN message to upper layers ***");
        f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_MFW_BV_03_eut4
        
  } // End of group g_TC_AUTO_IOT_DENM_MFW_BV_03
    
    /**
     * @desc    Verify complete Road Works Warning scenario
     * <pre>
     * Pics Selection: 
     * Config Id: CF-02
     * Initial conditions:
     *  with {
     *      EUT1 having sent Road Work Warning DEN messages D1 
     *          containing a 'speedLimit'
     *              indicating the value 30
     *          containing a 'drivingLaneStatus'
     *              indicating the value '0001'B
     *          containing a 'trafficFlowRule'
     *              indicating the value 'passToRight'
     *      and EUT1 having sent a DEN message D2
     *          containing a 'speedLimit'
     *              indicating the value 30
     *          containing a 'drivingLaneStatus'
     *              indicating the value '0011'B
     *          containing a 'trafficFlowRule
     *              indicating the value 'passToRight'
     *      and EUT1 having sent a DEN message D3
     *          containing a 'speedLimit'
     *              indicating the value 30
     *          containing a 'drivingLaneStatus'
     *              indicating the value '0101'B
     *          containing a 'trafficFlowRule'
     *              indicating the value 'passToLeft'
     *      and EUT2 having received the DEN messages D1, D2 and D3
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          EUT2 reaches the position POS0
     *      }
     *      then {
     *          EUT2 already indicates the speed limit information
     *      }
     *      when {
     *          EUT2 reaches the position POS1
     *      }
     *      then {
     *          EUT2 still indicates the speed limit information 
     *          and EUT2 already indicates the most outer lane closed
     *          and EUT2 already indicates the hardshoulder opened
     *      }
     *      when {
     *          EUT2 reaches the position POS2
     *      }
     *      then {
     *          EUT2 still indicates the speed limit information 
     *          and EUT2 already indicates the two most outer lanes closed
     *          and EUT2 already indicates the hardshoulder opened
     *      }
     *      when {
     *          EUT2 reaches the position POS3
     *      }
     *      then {
     *          EUT2 still indicates the speed limit information 
     *          and EUT2 already indicates the most right lane closed
     *          and EUT2 already indicates the hardshoulder closed
     *      }
     *      when {
     *          EUT2 reaches the position POS4
     *      }
     *      then {
     *          EUT2 stops indicating the speed limit information 
     *          and EUT2 stops indicating the lanes status
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_DENM_RWW_BV_01
     * @reference   ETSI EN 302 637-3 [5]
     */
  testcase TC_AUTO_IOT_DENM_RWW_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf02Up(v_eut1, v_eut2);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_DENM_RWW_BV_01_eut1(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_DENM_RWW_BV_01_eut2(v_eut2, PX_EUT2_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf02Down(v_eut1, v_eut2);
        
  } // End of TC_AUTO_IOT_DENM_RWW_BV_01
    
  group g_TC_AUTO_IOT_DENM_RWW_BV_01 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_DENM_RWW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_RWW_BV_01_eut1(
                                               in ItsAutoInteropGeonetworking p_eut,
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var integer v_states := 0;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // Wait for DENM1
      tc_ac.start;
      alt {
        [v_states == 0] geoNetworkingPort.receive(
                                                  mw_geoNwInd(
                                                              mw_geoNwPdu(
                                                                          mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                          ?,
                                                                                                                          ?,
                                                                                                                          e_btpB,
                                                                                                                          f_payload_template(
                                                                                                                                             PICS_DENM_BTP_DESTINATION_PORT, 
                                                                                                                                             PICS_DENM_BTP_SOURCE_PORT, 
                                                                                                                                             LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_denm_, 
                                                                                                                                             PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                             )
                                                                                                                          )))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          // Check DENM paylod
          if (f_check_payload_denm(
                                   v_gnInd, 
                                   mw_denm_stationId(
                                                     PX_EUT_DESC[p_eut_id].stationId,
                                                     mw_denm(
                                                             mw_denmMgmtCon_with_relevances(
                                                                                            ?, 
                                                                                            LibItsCommon_ASN1_NamedNumbers.StationType_roadSideUnit_,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            mw_referencePosition(PICS_Z1_D1_EP)
                                                                                            ),
                                                             mw_situation(
                                                                          LibItsCommon_ASN1_NamedNumbers.CauseCodeType_roadworks_, 
                                                                          ?
                      
                                                                          )))) == true) {
          v_states := v_states + 1;
            // Re-send DEN message to the other EUTs
            eutGeoNetworkingPort.send(
                                      m_forward_geoNetworkingInd(
                                                                 v_gnInd
                                                                 ));
          }
          tc_ac.start;
          repeat;
        }
        [v_states == 1] geoNetworkingPort.receive(
                                                  mw_geoNwInd(
                                                              mw_geoNwPdu(
                                                                          mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                          ?,
                                                                                                                          ?,
                                                                                                                          e_btpB,
                                                                                                                          f_payload_template(
                                                                                                                                             PICS_DENM_BTP_DESTINATION_PORT, 
                                                                                                                                             PICS_DENM_BTP_SOURCE_PORT, 
                                                                                                                                             LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_denm_, 
                                                                                                                                             PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                             )
                                                                                                                          )))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          // Check DENM paylod
          if (f_check_payload_denm(
                                   v_gnInd, 
                                   mw_denm_stationId(
                                                     PX_EUT_DESC[p_eut_id].stationId,
                                                     mw_denm(
                                                             mw_denmMgmtCon_with_relevances(
                                                                                            ?, 
                                                                                            LibItsCommon_ASN1_NamedNumbers.StationType_roadSideUnit_,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            mw_referencePosition(PICS_Z1_D2_EP)
                                                                                            ),
                                                             mw_situation(
                                                                          LibItsCommon_ASN1_NamedNumbers.CauseCodeType_roadworks_,
                                                                          ?
                                                                          )))) == true) {
          v_states := v_states + 1;
            // Re-send DEN message to the other EUTs
            eutGeoNetworkingPort.send(
                                      m_forward_geoNetworkingInd(
                                                                 v_gnInd
                                                                 ));
          }
          tc_ac.start;
          repeat;
        }
        [v_states == 2] geoNetworkingPort.receive(
                                                  mw_geoNwInd(
                                                              mw_geoNwPdu(
                                                                          mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                          ?,
                                                                                                                          ?,
                                                                                                                          e_btpB,
                                                                                                                          f_payload_template(
                                                                                                                                             PICS_DENM_BTP_DESTINATION_PORT, 
                                                                                                                                             PICS_DENM_BTP_SOURCE_PORT, 
                                                                                                                                             LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_denm_, 
                                                                                                                                             PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                             )
                                                                                                                          )))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          // Check DENM paylod
          if (f_check_payload_denm(
                                   v_gnInd, 
                                   mw_denm_stationId(
                                                     PX_EUT_DESC[p_eut_id].stationId,
                                                     mw_denm(
                                                             mw_denmMgmtCon_with_relevances(
                                                                                            ?, 
                                                                                            LibItsCommon_ASN1_NamedNumbers.StationType_roadSideUnit_,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            mw_referencePosition(PICS_Z1_D3_EP)
                                                                                            ),
                                                             mw_situation(
                                                                          LibItsCommon_ASN1_NamedNumbers.CauseCodeType_roadworks_,
                                                                          ?
                                                                          )))) == true) {
            // Re-send DEN message to the other EUTs
            eutGeoNetworkingPort.send(
                                      m_forward_geoNetworkingInd(
                                                                 v_gnInd
                                                                 ));
            log("*** " & testcasename() & ": PASS: The three expected DEN messages were received ***");
            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: The three expected DEN messages were not received in time ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      // Nothing to do
      f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_RWW_BV_01_eut1
        
    /**
     * @desc    Behavior function for EUT2 (TC_AUTO_IOT_DENM_RWW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_RWW_BV_01_eut2(
                                               in ItsAutoInteropGeonetworking p_eut,
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var HmiSignageEventInd v_hmiSignageEventInd;
      var EutGeoNetworking v_eutGeoNw;
      var integer v_counter;                            // DEN message counter
      var ThreeDLocation v_nextPosition2reach := PICS_POS0; // The different position to reach
      var float v_distance;                             // The vehicle position calculated using GN messages
      var integer v_isOnPosition := -1;                 // Set to unknown position
      var ThreeDLocation v_position;                    // CAM reference position

            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // Wait for EUT_1 DEN messages
    v_counter := 0;
      tc_wait.start;
      tc_ac.start;
      alt {
        [] eutGeoNetworkingPort.receive(
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   ?,
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?
                                                                                                                   )))) -> value v_eutGeoNw { // Receive a DEN message
          tc_ac.stop;
        v_counter := v_counter + 1;
          log("v_counter = ", v_counter);
          if (v_counter < 3) {
            tc_ac.start;
            repeat;
          } else {
            log("*** " & testcasename() & ": INFO: EUT2 (vehicle) receives RWW DENMs D1, D2 and D3 ***");
            tc_wait.stop;
            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          }
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ":FAIL: EUT2 (vehicle) does not receive RWW DENMs D1, D2 and D3 ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_error);
        }
      } // End of 'alt' statement
            
      // Test Body
      //tc_wait.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                                                ?,
                                                                                                                                ?,
                                                                                                                                e_btpB,
                                                                                                                                f_payload_template(
                                                                                                                                                   PICS_CAM_BTP_DESTINATION_PORT, 
                                                                                                                                                   PICS_CAM_BTP_SOURCE_PORT, 
                                                                                                                                                   LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_cam_, 
                                                                                                                                                   PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                                   )
                                                                                                                                )),
                                                                          c_llBroadcast
                                                                          )) -> value v_gnInd {
          tc_ac.stop;
          if (f_check_payload_cam(
                                  v_gnInd,
                                  mw_camMsg_BC_refPos(?),
                                  v_position) == true) {
            // Re-send DEN message to the other EUTs
            eutGeoNetworkingPort.send(
                                      m_forward_geoNetworkingInd(
                                                                 v_gnInd
                                                                 ));
            // Compute distance from v_nextPosition2reach
          v_distance := f_distance(
                                   v_position,
                                   v_nextPosition2reach
                                   );
            log("v_distance = ", v_distance, " - diff = ", v_distance - PX_PRE_DEFINED_SECURITY_DISTANCE, " - v_isOnPosition = ", v_isOnPosition);
            if (ff_abs(v_distance - PX_PRE_DEFINED_SECURITY_DISTANCE) < PX_DISTANCE_EPSILON) { // The expected position was reached
              select (v_isOnPosition) {
                case (-1) {
                v_isOnPosition := 0;
                v_nextPosition2reach := PICS_POS1;
                  log("Next position to reach (-1): ", v_nextPosition2reach);
                  tc_ac.start;
                  repeat;
                }
                case (0) {
                v_isOnPosition := 1;
                v_nextPosition2reach := PICS_POS2;
                  log("Next position to reach (0): ", v_nextPosition2reach);
                  tc_ac.start;
                  repeat;
                }
                case (1) {
                v_isOnPosition := 2;
                v_nextPosition2reach := PICS_POS3;
                  log("Next position to reach (1): ", v_nextPosition2reach);
                  tc_ac.start;
                  repeat;
                }
                case (2) {
                  log("Reach final position");
                v_isOnPosition := 3;
                  if (PX_CAPTURE_MODE == "off-link") {
                    log("*** " & testcasename() & ": PASS: Road Works Warning scenario complete ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                  } else {
                    repeat;
                  }
                }
              } // End of 'select' statement
            }
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [PX_CAPTURE_MODE == "on-link" and v_isOnPosition == 0] hmiPort.receive(
                                                                               mw_hmiSignageEventInd_roadworks_limitedspeed 
                                                                               ) -> value v_hmiSignageEventInd {
          log("*** " & testcasename() & ": INFO: EUT2 reaches position ", v_isOnPosition, " ***");
          tc_ac.stop;
          repeat; // Continue
        }
        [PX_CAPTURE_MODE == "on-link" and v_isOnPosition == 1] hmiPort.receive(
                                                                               HmiSignageEventInd:?/*TODO*/
                                                                               ) -> value v_hmiSignageEventInd {
          log("*** " & testcasename() & ": INFO: EUT2 reaches position ", v_isOnPosition, " ***");
          tc_ac.stop;
          repeat; // Continue
        }
        [PX_CAPTURE_MODE == "on-link" and v_isOnPosition == 2] hmiPort.receive(
                                                                               HmiSignageEventInd:?/*TODO*/
                                                                               ) -> value v_hmiSignageEventInd {
          log("*** " & testcasename() & ": INFO: EUT2 reaches position ", v_isOnPosition, " ***");
          tc_ac.stop;
          repeat; // Continue
        }
        [PX_CAPTURE_MODE == "on-link" and v_isOnPosition == 3] hmiPort.receive(
                                                                               HmiSignageEventInd:?/*TODO*/
                                                                               ) -> value v_hmiSignageEventInd {
          log("*** " & testcasename() & ": PASS: Road Works Warning scenario complete ***");
          tc_ac.stop;
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": FAIL: Road Works Warning scenario failure in position ", v_isOnPosition, " ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
        }
        /*[] tc_wait.timeout {
          log("*** " & testcasename() & ": INCONC: Road Works Warning scenario is incomplet ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
          }*/
      } // End of 'alt' statement
            
      // Postamble
      log("f_TC_AUTO_IOT_DENM_RWW_BV_01_eut2: verdict: ", getverdict);
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_RWW_BV_01_eut2
        
  } // End of group g_TC_AUTO_IOT_DENM_RWW_BV_01
    
    /**
     * @desc    Verify complete Road hazard Signals scenario
     * <pre>
     * Pics Selection: 
     * Config Id: CF-02
     * Initial conditions:
     *  with {
     *      EUT1 having sent Road Work Warning DEN messages D
     *         containing a management 
     *             containing eventPosition 
     *                 indicating POS1
     *             containing relevanceDistance 
     *                 indicating lessThan100m
     *             containing relevanceTrafficDirection 
     *                 indicating allTrafficDirections
     *         containing situation 
     *             containing eventType 
     *                 containing causeCode 
     *                     indicating a valid CAUSE_CODE (Table 4)
     *                 containing subCauseCode 
     *                     indicating a valid SUB_CAUSE_CODE (Table 5)
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          EUT2 reaches the position POS0
     *      }
     *      then {
     *          EUT2 already indicates the Road Hazard information
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_DENM_RHS_BV_01
     * @reference   ETSI EN 302 637-3 [5]
     */
  testcase TC_AUTO_IOT_DENM_RHS_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf02Up(v_eut1, v_eut2);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_DENM_RHS_BV_01_eut1(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_DENM_RHS_BV_01_eut2(v_eut2, PX_EUT2_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf02Down(v_eut1, v_eut2);
        
  } // End of TC_AUTO_IOT_DENM_RHS_BV_01
    
  group g_TC_AUTO_IOT_DENM_RHS_BV_01 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_DENM_RHS_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_RHS_BV_01_eut1(
                                               in ItsAutoInteropGeonetworking p_eut,
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // Wait for DENM1
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                             ?,
                                                                                                             ?,
                                                                                                             e_btpB,
                                                                                                             f_payload_template(
                                                                                                                                PICS_DENM_BTP_DESTINATION_PORT, 
                                                                                                                                PICS_DENM_BTP_SOURCE_PORT, 
                                                                                                                                LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_denm_, 
                                                                                                                                PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                )
                                                                                                             )))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          // Check DENM paylod
          if (f_check_payload_denm(
                                   v_gnInd, 
                                   mw_denm_stationId(
                                                     PX_EUT_DESC[p_eut_id].stationId,
                                                     mw_denm(
                                                             mw_denmMgmtCon_with_relevances(
                                                                                            ?, 
                                                                                            LibItsCommon_ASN1_NamedNumbers.StationType_roadSideUnit_,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            -,
                                                                                            lessThan100m,
                                                                                            allTrafficDirections,
                                                                                            mw_referencePosition(PICS_Z1_D1_EP)
                                                                                            ),
                                                             mw_situation(
                                                                          PX_DENM_CAUSE_VA, 
                                                                          PX_DENM_SUBCAUSE_VA                      
                                                                          )))) == true) {
              // Re-send DEN message to the other EUTs
              eutGeoNetworkingPort.send(
                                        m_forward_geoNetworkingInd(
                                                                   v_gnInd
                                                                   ));
            log("*** " & testcasename() & ": PASS: The expected DEN messages were received ***");
            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: The expected DEN message were not received in time ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
      
      // Test Body
      // Nothing to do
      f_selfOrClientSyncAndVerdict(c_tbDone, e_success);

      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_RHS_BV_01_eut1
        
    /**
     * @desc    Behavior function for EUT2 (TC_AUTO_IOT_DENM_RHS_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_RHS_BV_01_eut2(
                                               in ItsAutoInteropGeonetworking p_eut,
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var EutGeoNetworking v_eutGeoNw;
      var float v_distance;
      var ThreeDLocation v_position;                    // CAM reference position
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // EUT2 having received a DEN message
      tc_ac.start;
      alt {
        [] eutGeoNetworkingPort.receive(
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   ?,
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?
          )))) { 
          tc_ac.stop;
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: Expected DEN message not received ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                                                ?,
                                                                                                                                ?,
                                                                                                                                e_btpB,
                                                                                                                                f_payload_template(
                                                                                                                                                   PICS_CAM_BTP_DESTINATION_PORT, 
                                                                                                                                                   PICS_CAM_BTP_SOURCE_PORT, 
                                                                                                                                                   LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_cam_, 
                                                                                                                                                   PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                                   )
                                                                                                                                )),
                                                                          c_llBroadcast
                                                                          )) -> value v_gnInd {
          tc_ac.stop;
          if (f_check_payload_cam(
                                  v_gnInd,
                                  mw_camMsg_BC_refPos(?),
                                  v_position) == true) {
            // Compute distance from POS0
          v_distance := f_distance(
                                   v_position,
                                   PICS_POS0
                                   );
            log("v_distance = ", v_distance, " - diff = ", v_distance - PX_PRE_DEFINED_SECURITY_DISTANCE);
            if (ff_abs(v_distance - PX_LATERAL_COLLISION_SECURITY_DISTANCE) < PX_DISTANCE_EPSILON) { // Position PICS_POS0 was reached
              log("*** " & testcasename() & ": INFO: EUT2 has reached POS0 ***");
              if (PX_CAPTURE_MODE == "off-link") {
                log("*** " & testcasename() & ": PASS: The Road Hazard Signal information was received on EUT ", PX_EUT_DESC[p_eut_id].stationId, "***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
              }
            } else {
              // Continue
              tc_ac.start;
              repeat;
            }
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [PX_CAPTURE_MODE == "on-link"] hmiPort.receive(mw_hmiSignageEventInd_roadHazardSignal) {
          tc_ac.stop;
          log("*** " & testcasename() & ": PASS: The Road Hazard Signal information was received on EUT ", PX_EUT_DESC[p_eut_id].stationId, "***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: CAM messages for EUT ", PX_EUT_DESC[p_eut_id].stationId, " not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_RHS_BV_01_eut2
        
  } // End of group g_TC_AUTO_IOT_DENM_RHS_BV_01 
    
    /**
     * @desc    Verify complete Stationary Vehicle Warning scenario 
     * <pre>
     * Pics Selection: 
     * Config Id: CF-02
     * Initial conditions:
     *  with {
     *      EUT1 having sent Road Work Warning DEN messages D
     *         containing a management 
     *             containing eventPosition 
     *                 indicating POS1
     *             containing relevanceDistance 
     *                 indicating lessThan100m
     *             containing relevanceTrafficDirection 
     *                 indicating allTrafficDirections
     *         containing situation 
     *             containing eventType 
     *                 containing causeCode 
     *                     indicating a valid CAUSE_CODE (Table 4)
     *                 containing subCauseCode 
     *                     indicating a valid SUB_CAUSE_CODE (Table 5)
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          EUT2 reaches the position POS0
     *      }
     *      then {
     *          EUT2 already indicates the Stationary Vehicle Information
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_DENM_SVW_BV_01
     * @reference   ETSI EN 302 637-3 [5]
     */
  testcase TC_AUTO_IOT_DENM_SVW_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf02Up(v_eut1, v_eut2);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_DENM_SVW_BV_01_eut1(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_DENM_SVW_BV_01_eut2(v_eut2, PX_EUT2_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf02Down(v_eut1, v_eut2);
        
  } // End of TC_AUTO_IOT_DENM_SVW_BV_01
    
  group g_TC_AUTO_IOT_DENM_SVW_BV_01 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_DENM_SVW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_SVW_BV_01_eut1(
                                               in ItsAutoInteropGeonetworking p_eut,
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // EUT1 having sent a DEN message
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                             ?,
                                                                                                             ?,
                                                                                                             e_btpB,
                                                                                                             f_payload_template(
                                                                                                                                PICS_DENM_BTP_DESTINATION_PORT, 
                                                                                                                                PICS_DENM_BTP_SOURCE_PORT, 
                                                                                                                                LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_denm_, 
                                                                                                                                PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                )
          )))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          // Check DENM paylod
          if (f_check_payload_denm(
                                   v_gnInd, 
                                   mw_denm_stationId(
                                                     PX_EUT_DESC[p_eut_id].stationId,
                                                     mw_denm(
                                                             mw_denmMgmtCon_with_relevances_position(
                                                                                                     ?,
                                                                                                     LibItsCommon_ASN1_NamedNumbers.StationType_heavyTruck_,
                                                                                                     -,
                                                                                                     4,
                                                                                                     -,
                                                                                                     -,
                                                                                                     mw_referencePosition(PICS_UC2_HEAVY_TRUCK_POS)
                                                                                                     ),
                                                             mw_situation(
                                                                          PICS_UC2_CAUSE,
                                                                          PICS_UC2_SUBCAUSE
                                                                          )))) == true) {
            // Re-send DEN message to the other EUTs
            eutGeoNetworkingPort.send(
                                      m_forward_geoNetworkingInd(
                                                                 v_gnInd
                                                                 ));
            log("*** " & testcasename() & ": PASS: The expected DEN message were received ***");
            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: Expected DEN message not received ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      // Nothing to do
      f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_SVW_BV_01_eut1
        
    /**
     * @desc    Behavior function for EUT2 (TC_AUTO_IOT_DENM_SVW_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_SVW_BV_01_eut2(
                                               in ItsAutoInteropGeonetworking p_eut,
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var EutGeoNetworking v_eutGeoNw;
      var float v_distance;
      var ThreeDLocation v_position;                    // CAM reference position
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // EUT2 having received a DEN message
      tc_ac.start;
      alt {
        [] eutGeoNetworkingPort.receive(
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   ?,
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?
          )))) { // Receive a DEN message
          tc_ac.stop;
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: Expected DEN message not received ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                                                ?,
                                                                                                                                ?,
                                                                                                                                e_btpB,
                                                                                                                                f_payload_template(
                                                                                                                                                   PICS_CAM_BTP_DESTINATION_PORT, 
                                                                                                                                                   PICS_CAM_BTP_SOURCE_PORT, 
                                                                                                                                                   LibItsCommon_ASN1_NamedNumbers.ItsPduHeader_messageID_cam_, 
                                                                                                                                                   PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                                   )
                                                                                                                                )),
                                                                          c_llBroadcast
                                                                          )) -> value v_gnInd {
          tc_ac.stop;
          if (f_check_payload_cam(
                                  v_gnInd,
                                  mw_camMsg_BC_refPos(?),
                                  v_position) == true) {
            // Compute distance from POS0
          v_distance := f_distance(
                                   v_position,
                                   PICS_POS0
                                   );
            log("v_distance = ", v_distance, " - diff = ", v_distance - PX_PRE_DEFINED_SECURITY_DISTANCE);
            if (ff_abs(v_distance - PX_PRE_DEFINED_SECURITY_DISTANCE) < PX_DISTANCE_EPSILON) { // Position PICS_POS0 was reached
              log("*** " & testcasename() & ": INFO: EUT2 has reached POS0 ***");
              if (PX_CAPTURE_MODE == "off-link") {
                log("*** " & testcasename() & ": PASS: The Stationary Vehicle Warning information was received on EUT ", PX_EUT_DESC[p_eut_id].stationId, "***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
              }
            } else {
              tc_ac.start;
              repeat;
            }
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [PX_CAPTURE_MODE == "on-link"] hmiPort.receive(mw_hmiSignageEventInd_stationaryVehicleWarning) {
          tc_ac.stop;
          log("*** " & testcasename() & ": PASS: The Stationary Vehicle Warning information was received on EUT ", PX_EUT_DESC[p_eut_id].stationId, "***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: CAM messages for EUT ", PX_EUT_DESC[p_eut_id].stationId, " not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_SVW_BV_01_eut2
        
  } // End of group g_TC_AUTO_IOT_DENM_SVW_BV_01 
    
    /**
     * @desc    Verify complete complete Geo-broadcast message caching scenario 
     * <pre>
     * Pics Selection: 
     * Config Id: CF-01with EUT4 off-link
     * Initial conditions:
     *  with {
     *      itsGnNonAreaForwardingAlgorithm of EUT1 set to GREEDY
     *      itsGnNonAreaForwardingAlgorithm of EUT2 set to GREEDY
     *      itsGnNonAreaForwardingAlgorithm of EUT4 is SIMPLE
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          EUT1 is requested to send DEN message
     *              encapsulated in a GBC packet
     *          containing Basic Header
     *              containing RHL field
     *                  indicating a value > 1
     *          containing DestinationArea
     *              indicating the TARGET_GEOAREA
     *      }
     *      then {
     *          EUT1 sends a GBC packet
     *              containing Basic Header
     *                  containing RHL field
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *                  containing the DEN message
     *              encapsulated in a LL packet
     *                  containing a destination MAC address
     *                      indicating the EUT2 address
     *      }
     *      when {
     *          EUT2 receives the GBC packet from EUT1
     *      }
     *      then {
     *          EUT2 buffers the GBC packet from EUT1
     *      }
     *      when {
     *          EUT2 and EUT4 become on-link
     *      }
     *      then {
     *          EUT2 sends a GBC packet
     *              containing Basic Header
     *                  containing RHL field
     *                      indicating value decreased by 1
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *                  containing the DEN message
     *              encapsulated in a LL packet
     *                  containing a destination MAC address
     *                      indicating the EUT4 address
     *              and EUT3 does not receive the GBC packet from EUT1
     *      }
     *      when {
     *          EUT4 receives the GBC packet from EUT2
     *              containing Basic Header
     *              containing RHL field
     *                  indicating value decreased by 1
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *                  containing the DEN message
     *      }
     *      then {
     *          EUT4 provides the DEN message to upper layers 
     *          and EUT4 sends a GBC packet
     *              containing Basic Header
     *                  containing RHL field
     *                      indicating value decreased by 1
     *              containing DestinationArea
     *                  indicating the TARGET_GEOAREA
     *              containing Payload
     *              containing the DEN message
     *              encapsulated in a LL packet 
     *                  containing a destination MAC address
     *                      indicating broadcast address
     *      }
     *      when {
     *      EUT2 receives the GBC packet from EUT4
     *      }
     *      then {
     *          EUT2 discards the GBC packet
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_DENM_GMC_BV_01
     * @reference   ETSI EN 302 636-4-1 Clauses 9.3.11, D & E2 [2]
     */
  testcase TC_AUTO_IOT_DENM_GMC_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
    var ItsAutoInteropGeonetworking v_eut3 := null;
    var ItsAutoInteropGeonetworking v_eut4 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf01Up(v_eut1, v_eut2, v_eut3, v_eut4);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_DENM_GMC_BV_01_eut1(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_DENM_GMC_BV_01_eut2(v_eut2, PX_EUT2_ID));
    // v_eut3 not used
    v_eut4.start(f_TC_AUTO_IOT_DENM_GMC_BV_01_eut4(v_eut4, PX_EUT4_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(4, {c_prDone, c_initDone, c_tbDone});
        
    // Cleanup
    f_mtcCf01Down(v_eut1, v_eut2, v_eut3, v_eut4);
        
  } // End of TC_AUTO_IOT_DENM_GMC_BV_01
    
  group g_TC_AUTO_IOT_DENM_GMC_BV_01 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_DENM_GMC_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_GMC_BV_01_eut1(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive( // Filter broadcasted DENM
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                      ?,
                                                                                                                                      ?,
                                                                                                                                      e_btpB, 
                                                                                                                                      ?/*mw_denm_stationId(
                                                                                                                                         PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                         )*/)),
                                                                          PX_EUT_DESC[PX_EUT2_ID].ll_mac_address
                                                                          )) -> value v_gnInd { //  Receives the triggered DENM message
          tc_ac.stop;
          // Re-send DEN message to EUT2s
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          log("*** " & testcasename() & ": INFO: EUT1 sends a GBC packet ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: EUT1 does not send requested DEN message ***");
          f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
        }
      } // End of 'alt' statement
            
      // Test Body
      f_selfOrClientSyncAndVerdict(c_initDone, e_success);
      tc_wait.start;
      alt {
        [] geoNetworkingPort.receive( 
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                      ?,
                                                                                                                                      ?,
                                                                                                                                      e_btpB, 
                                                                                                                                      ?/*mw_denm_stationId(
                                                                                                                                         ? // FIXME complement(PX_EUT_DESC[p_eut_id].stationId)
                                                                                                                                         )*/)),
                                                                          ?
                                                                          )) -> value v_gnInd { 
          tc_wait.stop;
          log("*** " & testcasename() & ": FAIL: Unexpected DEN message received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": PASS: Geo-broadcast message caching scenario succeed ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_GMC_BV_01_eut1
        
    /**
     * @desc    Behavior function for EUT2 (TC_AUTO_IOT_DENM_GMC_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_GMC_BV_01_eut2(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [] eutGeoNetworkingPort.receive( // EUT2 receives the GBC packet from EUT1
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   ?,
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?/*mw_denm_stationId(
                                                                                                                      PX_EUT_DESC[PX_EUT1_ID].stationId
                                                                                                                      )*/)))) -> value v_eutGeoNw {
          // Here, GBC packet should be buffered
          f_selfOrClientSyncAndVerdict(c_initDone, e_success);
          // Now, we have to check for EUT4 to broadcast the DENM message
          repeat;
        }
        [] eutGeoNetworkingPort.receive(
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB, 
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[PX_EUT4_ID].stationId
                                                                                                                                               )*/)),
                                                                                c_llBroadcast
                                                                                )) -> value v_eutGeoNw { 
          tc_wait.stop;
          log("*** " & testcasename() & ": PASS: DEN message was broadcasted by EUT4 ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Geo-broadcast message caching scenario is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_GMC_BV_01_eut2
        
    /**
     * @desc    Behavior function for EUT4 (TC_AUTO_IOT_DENM_GMC_BV_01)
     */
    function f_TC_AUTO_IOT_DENM_GMC_BV_01_eut4(
                                               in ItsAutoInteropGeonetworking p_eut, 
                                               in integer p_eut_id
                                               ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var EutGeoNetworking v_eutGeoNw;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      f_selfOrClientSyncAndVerdict(c_initDone, e_success);
      // EUT2 and EUT4 become on-link
      if (PX_CAPTURE_MODE == "on-link") {
        ItsAutoInterop_Functions.f_utTriggerEvent(UtAutoInteropTrigger:{utRadioOnOff := true});
      }
      tc_ac.start;
      alt {
        [] eutGeoNetworkingPort.receive(
                                        mw_eutGeoNwInd_withLinkLayerDestination(
                                                                                mw_geoNwPdu(
                                                                                            mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                            ?,
                                                                                                                                            ?,
                                                                                                                                            e_btpB,
                                                                                                                                            ?/*mw_denm_stationId(
                                                                                                                                               PX_EUT_DESC[PX_EUT1_ID].stationId
                                                                                                                                               )*/)),
                                                                                PX_EUT_DESC[p_eut_id].ll_mac_address
                                                                                )) -> value v_eutGeoNw { // Receive a DEN message from EUT2
          tc_ac.stop;
          // Now check that EUT4 brodcasts the DENM message
          tc_ac.start;
          repeat;
        }
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                                      ?,
                                                                                                                                      ?,
                                                                                                                                      e_btpB,
                                                                                                                                      ?/*mw_denm_stationId(
                                                                                                                                         PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                         )*/)),
                                                                          c_llBroadcast
                                                                          )) -> value v_gnInd { // EUT4 has brodcasted the DENM message
          tc_ac.stop;
          // Re-send DEN message to the other EUTs
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          log("*** " & testcasename() & ": PASS: Geo-broadcast message caching scenario succeed ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": FAIL: Geo-broadcast message caching scenario is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_DENM_GMC_BV_01_eut4
        
  } // End of group g_TC_AUTO_IOT_DENM_GMC_BV_01
    
    /**
     * @desc    Verify complete neighbors detection scenario based on CA messages and/or beacons
     * <pre>
     * Pics Selection: 
     * Config Id: CF-03
     * Initial conditions:
     * with {
     *     EUT1, EUT2 and EUT3 being on-link
     * }
     * Expected behaviour:
     * ensure that {
     *     when {
     *         EUT1 sends CA messages
     *             containing cam
     *                 containing camParameters
     *                     containing basicContainer 
     *                         containing referencePosition
     *                             indicating POSITION_1
     *     }
     *     then {
     *         EUT2 indicates EUT1 as neighbour
     *         EUT3 indicates EUT1 as neighbour
     *     }
     *     when {
     *         EUT2 sends CA messages
     *             containing cam
     *                 containing camParameters
     *                     containing basicContainer 
     *                         containing referencePosition
     *                             indicating POSITION_1
     *     }
     *     then {
     *         EUT1 indicates EUT1 as neighbour
     *         EUT3 indicates EUT1 as neighbour
     *     }
     *     when {
     *         EUT3 sends CA messages
     *             containing cam
     *                 containing camParameters
     *                     containing basicContainer 
     *                         containing referencePosition
     *                             indicating POSITION_1
     *     }
     *     then {
     *         EUT1 indicates EUT1 as neighbour
     *         EUT2 indicates EUT1 as neighbour
     *     }
     * }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_CAM_NBD_BV_01
     * @reference   ETSI EN 302 636-2 ETSI EN 302 637-2 [4]
     */
  testcase TC_AUTO_IOT_CAM_NBD_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
    var ItsAutoInteropGeonetworking v_eut3 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf03Up(v_eut1, v_eut2, v_eut3);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_CAM_NBD_BV_01_eut(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_CAM_NBD_BV_01_eut(v_eut2, PX_EUT2_ID));
    v_eut3.start(f_TC_AUTO_IOT_CAM_NBD_BV_01_eut(v_eut3, PX_EUT3_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(3, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf03Down(v_eut1, v_eut2, v_eut3);
        
  } // End of TC_AUTO_IOT_CAM_NBD_BV_01
    
  group g_TC_AUTO_IOT_CAM_NBD_BV_01 { 
        
    /**
     * @desc    Behavior function for EUT (TC_AUTO_IOT_CAM_NBD_BV_01)
     */
    function f_TC_AUTO_IOT_CAM_NBD_BV_01_eut(
                                             in ItsAutoInteropGeonetworking p_eut,
                                             in integer p_eut_id
                                             ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var HmiNeighborEventInds v_hmiNeighborEventInds;
      var HmiNeighborEventInds v_expected_neighbors := {};
            
      // Build the list of the expected neighbors
      for (var integer i := 0; i < lengthof(PX_EUT_DESC); i := i + 1) {
        if (i != p_eut_id) {
          var octetstring v := int2oct(PX_EUT_DESC[i].stationId, 4); // FIXME How to improve type conversion
          v_expected_neighbors[lengthof(v_expected_neighbors)].mid := PX_EUT_DESC[i].mid;
          v_expected_neighbors[lengthof(v_expected_neighbors)].stationId := oct2int(v); // FIXME How to improve type conversion
        }
      } // End of 'for' statement
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt { 
        [] geoNetworkingPort.receive( // Filter broadcasted CAM
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                                                ?,
                                                                                                                                ?,
                                                                                                                                e_btpB, 
                                                                                                                                ?/*mw_cam_stationId(
                                                                                                                                   -,
                                                                                                                                   ? // FIXME complement(PX_EUT_DESC[p_eut_id].stationId)
                                                                                                                                   )*/)),
                                                                          c_llBroadcast
                                                                          )) -> value v_gnInd { //  Receives a broadcast MAC address
          // Broadcast CA message to the other EUTs
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          repeat;
        }
        [] geoNetworkingPort.receive( // Filter broadcasted beacon
                                     mw_geoNwInd_withLinkLayerDestination(
                                                                          mw_geoNwPdu(
                                                                                      mw_geoNwShbPacket(
                                                                                                        mw_longPosVectorAny(
                                                                                                                            mw_gnAddressMid(
                                                                                                                                            ? // FIXME complement(PX_EUT_DESC[p_eut_id].mid)
                                                                                                                                            )))),
                                                                          c_llBroadcast
                                                                          )) -> value v_gnInd { //  Receives a broadcast MAC address
          // Broadcast Beacon message to the other EUTs
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          repeat;
        }
        [] hmiPort.receive(
                           HmiNeighborEventInds:?
                           ) -> value v_hmiNeighborEventInds {
          for (var integer v_i := 0; v_i < lengthof(v_hmiNeighborEventInds); v_i := v_i + 1) {
            if (match(v_expected_neighbors, superset(m_hmiNeighborEventInd(v_hmiNeighborEventInds[v_i].mid, v_hmiNeighborEventInds[v_i].stationId)))) {
              // Remove item from the expected list
              for (var integer v_j := 0; v_j < lengthof(v_expected_neighbors); v_j := v_j + 1) {
                if (v_expected_neighbors[v_j].mid == v_hmiNeighborEventInds[v_i].mid) {
                  v_expected_neighbors[v_j] := {};
                  break;
                }
              } // End of 'for' statement
            } // else nothing to do
          } // End of 'for' statement
          // Check if all neighbors were detected
          if (lengthof(v_expected_neighbors) == 0) {
            log("*** " & testcasename() & ": PASS: Neighbors were detected by EUT #", p_eut_id, " ***");
            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
          } else {
            repeat;
          }
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": FAIL: Neighbors were not be detected by EUT #", p_eut_id, " ***");
        }
      } // End of 'alt' statement
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_CAM_NBD_BV_01_eut
        
  } // End of group g_TC_AUTO_IOT_CAM_NBD_BV_01
    
    /**
     * @desc    Verify complete longitudinal collision risk scenario based on CA messages
     * <pre>
     * Pics Selection: 
     * Config Id: CF-02
     * Initial conditions:
     *  with {
     *      EUT1 having moved slowly between positions POS1 and POS2
     *      and EUT2 having moved from Start position to End position
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          distance between EUT1 and EUT2 becomes less than the pre-defined security distance
     *      }
     *      then {
     *          EUT1 indicates the forward collision risk
     *          and EUT2 indicates the forward collision risk
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_CAM_CRW_BV_01
     * @reference   ETSI EN 302 637-2 [4]
     */
  testcase TC_AUTO_IOT_CAM_CRW_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf02Up(v_eut1, v_eut2);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_CAM_CRW_BV_01_eut(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_CAM_CRW_BV_01_eut(v_eut2, PX_EUT2_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf02Down(v_eut1, v_eut2);
        
  } // End of TC_AUTO_IOT_CAM_CRW_BV_01
    
  group g_TC_AUTO_IOT_CAM_CRW_BV_01 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_CAM_CRW_BV_01)
     */
    function f_TC_AUTO_IOT_CAM_CRW_BV_01_eut(
                                             in ItsAutoInteropGeonetworking p_eut,
                                             in integer p_eut_id
                                             ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var float v_distance;
      var ThreeDLocation v_myPosition;
      var ThreeDLocation v_position;                    // CAM reference position
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // Acquire my current position
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                       ?,
                                                                                                       ?,
                                                                                                       e_btpB,
                                                                                                       ?/*mw_cam_stationId(
                                                                                                          -,
                                                                                                          PX_EUT_DESC[p_eut_id].stationId
                                                                                                          )*/)))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          // Re-send DEN message to the other EUTs
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          // Store my current position
        v_myPosition.latitude := v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector.latitude;
        v_myPosition.longitude := v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector.longitude;
        v_myPosition.elevation := 0; //v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector.altitude;
        }
        [] geoNetworkingPort.receive( // TODO Move to default
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwShbPacketWithNextHeaderAndPayload
                                                             ))) {
          tc_ac.stop;
          tc_ac.start;
          repeat;
        }
        [] eutGeoNetworkingPort.receive( // TODO Move to default
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwShbPacketWithNextHeaderAndPayload
                                                                   ))) {
          tc_ac.stop;
          tc_ac.start;
          repeat;
        }
        [] geoNetworkingPort.receive( // TODO Move to default
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                             ?,
                                                                                                             ?,
                                                                                                             e_btpB,
                                                                                                             ?//mw_denm_stationId
                                                                                                             )))) {
          tc_ac.stop;
          tc_ac.start;
          repeat;
        }
        [] eutGeoNetworkingPort.receive( // TODO Move to default
                                        mw_eutGeoNwInd(
                                                       mw_geoNwPdu(
                                                                   mw_geoNwBroadcastPacketWithNextHeaderAndPayload(
                                                                                                                   ?,
                                                                                                                   ?,
                                                                                                                   e_btpB,
                                                                                                                   ?//mw_denm_stationId
                                                                                                                   )))) {
          tc_ac.stop;
          tc_ac.start;
          repeat;
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: CAM messages for EUT ", PX_EUT_DESC[p_eut_id].stationId, " not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                       ?,
                                                                                                       ?,
                                                                                                       e_btpB,
                                                                                                       ?/*mw_cam_stationId(
                                                                                                          -,
                                                                                                          PX_EUT_DESC[p_eut_id].stationId
                                                                                                          )*/)))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          // Re-send DEN message to the other EUTs
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          // Store my current position
        v_myPosition.latitude := v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector.latitude;
        v_myPosition.longitude := v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector.longitude;
        v_myPosition.elevation := 0; //v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector.altitude;
        }
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                       ?,
                                                                                                       ?,
                                                                                                       e_btpB,
                                                                                                       ?//mw_cam_stationId
                                                                                                       )))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          if (f_check_payload_cam(
                                  v_gnInd,
                                  mw_camMsg_BC_refPos(?),
                                  v_position) == true) {
            // Re-send CA message to the other EUTs
            eutGeoNetworkingPort.send(
                                      m_forward_geoNetworkingInd(
                                                                 v_gnInd
                                                                 ));
            // Store my current position
          v_distance := f_distance(
                                   v_position,
                                   v_myPosition
                                   );
            if (v_distance >= PX_FORWARD_COLLISION_SECURITY_DISTANCE) { // TODO Check elevation
              tc_ac.start;
              repeat;
            } // else, nothing to do
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: CAM messages for EUT ", PX_EUT_DESC[p_eut_id].stationId, " not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
      tc_ac.start;
      alt { // Check that Forward Collision Risk was received 
        [] hmiPort.receive(mw_hmiSignageEventInd_forwardCollisionRisk) {
          tc_ac.stop;
          log("*** " & testcasename() & ": PASS: The Forward Collision Risk signage was received on EUT ", PX_EUT_DESC[p_eut_id].stationId, "***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": FAIL: Expected message not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_CAM_CRW_BV_01_eut
        
  } // End of group g_TC_AUTO_IOT_CAM_CRW_BV_01 
    
    /**
     * @desc    Verify complete intersection collision risk scenario based on CA messages
     * <pre>
     * Pics Selection: 
     * Config Id: CF-04
     * Initial conditions:
     *  with {
     *      EUT1 having moved from Start1 position to End1 position
     *      and EUT2 having moved from Start2 position to End2 position
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          EUT1 and EUT2 approach simultaneously POS3
     *      }
     *      then {
     *          EUT1 indicates the lateral collision risk
     *          and EUT2 indicates the lateral  collision risk
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_CAM_CRW_BV_02
     * @reference   ETSI EN 302 637-2 [4]
     */
  testcase TC_AUTO_IOT_CAM_CRW_BV_02() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf02Up(v_eut1, v_eut2);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_CAM_CRW_BV_02_eut(v_eut1, PX_EUT1_ID));
    v_eut2.start(f_TC_AUTO_IOT_CAM_CRW_BV_02_eut(v_eut2, PX_EUT2_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf02Down(v_eut1, v_eut2);
        
  } // End of TC_AUTO_IOT_CAM_CRW_BV_02
    
  group g_TC_AUTO_IOT_CAM_CRW_BV_02 { 
        
    /**
     * @desc    Behavior function for EUT1 (TC_AUTO_IOT_CAM_CRW_BV_02)
     */
    function f_TC_AUTO_IOT_CAM_CRW_BV_02_eut(
                                             in ItsAutoInteropGeonetworking p_eut,
                                             in integer p_eut_id
                                             ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var float v_distance;
      var ThreeDLocation v_position;                    // CAM reference position
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // Nothing to do
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_ac.start;
      alt {
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                       ?,
                                                                                                       ?,
                                                                                                       e_btpB,
                                                                                                       ?/*mw_cam_stationId(
                                                                                                          -,
                                                                                                          PX_EUT_DESC[p_eut_id].stationId
                                                                                                          )*/)))) -> value v_gnInd { // Receive a DEN message
          tc_ac.stop;
          if (f_check_payload_cam(
                                  v_gnInd,
                                  mw_camMsg_BC_refPos(?),
                                  v_position) == true) {
            // Re-send CA message to the other EUTs
            eutGeoNetworkingPort.send(
                                      m_forward_geoNetworkingInd(
                                                                 v_gnInd
                                                                 ));
            // Compute distance from POS3
          v_distance := f_distance(
                                   v_position,
                                   PICS_POS3
                                   );
            if (v_distance >= PX_LATERAL_COLLISION_SECURITY_DISTANCE) { // TODO Check elevation
              // Continue
              tc_ac.start;
              repeat;
            } // else, nothing to do
          } else {
            tc_ac.start;
            repeat;
          }
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": INCONC: CAM messages for EUT ", PX_EUT_DESC[p_eut_id].stationId, " not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
      } // End of 'alt' statement
      tc_ac.start;
      alt { // Check that Lateral Collision Risk was received 
        [] hmiPort.receive(mw_hmiSignageEventInd_lateralCollisionRisk) {
          tc_ac.stop;
          log("*** " & testcasename() & ": PASS: The Lateral Collision Risk signage was received on EUT ", PX_EUT_DESC[p_eut_id].stationId, "***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": FAIL: Expected message not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_CAM_CRW_BV_02_eut
        
  } // End of group g_TC_AUTO_IOT_CAM_CRW_BV_02 
    
    /**
     * @desc    Verify complete resolution of duplicate address conflict scenario based on GN messages
     * <pre>
     * Pics Selection: 
     * Config Id: CF-01
     * Initial conditions:
     *  with {
     *      EUT1 and EUT2 being configured with the same GN address
     *      and EUT1 and EUT2 being off-link
     *  }
     * Expected behaviour:
     *  ensure that {
     *      when {
     *          EUT1 and EUT2 become on-link
     *      }
     *      then {
     *          EUT1 changes its GN address
     *          and EUT2 changes its GN address
     *      }
     *      when {
     *          EUT1 sends CA messages
     *              containing cam
     *                  containing camParameters
     *                  containing basicContainer 
     *                      containing referencePosition
     *      }
     *      then {
     *          EUT2 indicates EUT1 as neighbour
     *      }
     *      when {
     *          EUT2 sends CA messages 
     *          containing cam
     *              containing camParameters
     *                  containing basicContainer 
     *                      containing referencePosition
     *      }
     *      then {
     *          EUT1 indicates EUT2 as neighbour
     *      }
     *  }
     * </pre>
     *
     * @see         Draft ETSI TS yyy xxx-2 V0.0.8 (2017-03) TD_AUTO_IOT_GN_DAD_BV_01
     * @reference   ETSI EN 302 636-4-1 [2] Clause 9.2.1.5
     */
  testcase TC_AUTO_IOT_GN_DAD_BV_01() runs on ItsMtc system ItsAutoInteropGeoNetworkingSystem {
        
    // Local variables
    var ItsAutoInteropGeonetworking v_eut1 := null;
    var ItsAutoInteropGeonetworking v_eut2 := null;
        
    // Test control
    /*if (not PICS_GN_LS_FWD) {
      log("*** " & testcasename() & ": PICS_GN_LS_FWD required for executing the TC ***");
      setverdict(inconc);
      stop;
      }*/
        
    // Test component configuration
    f_mtcCf02Up(v_eut1, v_eut2);
        
    // Preamble
        
    // Start components
    v_eut1.start(f_TC_AUTO_IOT_GN_DAD_BV_01_eut(v_eut1, PX_EUT1_ID, PX_EUT2_ID));
    v_eut2.start(f_TC_AUTO_IOT_GN_DAD_BV_01_eut(v_eut2, PX_EUT2_ID, PX_EUT1_ID));
        
    // Synchronization
    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
        
    // Cleanup
    f_mtcCf02Down(v_eut1, v_eut2);
        
  } // End of TC_AUTO_IOT_GN_DAD_BV_01
    
  group g_TC_AUTO_IOT_GN_DAD_BV_01 { 
        
    /**
     * @desc    Behavior function for EUTs (TC_AUTO_IOT_GN_DAD_BV_01)
     */
    function f_TC_AUTO_IOT_GN_DAD_BV_01_eut(
                                            in ItsAutoInteropGeonetworking p_eut,
                                            in integer p_eut_id,
                                            in integer p_eut_id_neighbour
                                            ) runs on ItsAutoInteropGeonetworking {
            
      // Local variables
      var GeoNetworkingInd v_gnInd;
      var GN_Address v_gnAddr;
      var boolean v_getFirstCam := false;
      var HmiNeighborEventInds v_hmiNeighborEventInds;
            
      // Test component configuration
      f_cfPtcUp(p_eut);
            
      // Preamble
      f_prDefault();
      // EUT1 and EUT2 become on-link
      if (PX_CAPTURE_MODE == "on-link") {
        ItsAutoInterop_Functions.f_utTriggerEvent(UtAutoInteropTrigger:{utRadioOnOff := true});
      }
      f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
      // Test Body
      tc_wait.start;
      alt {
        [v_getFirstCam == false] geoNetworkingPort.receive(
                                                           mw_geoNwInd(
                                                                       mw_geoNwPdu(
                                                                                   mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                                             ?,
                                                                                                                             ?,
                                                                                                                             e_btpB,
                                                                                                                             ?/*mw_cam_stationId(
                                                                                                                                -,
                                                                                                                                PX_EUT_DESC[p_eut_id].stationId
                                                                                                                                )*/)))) -> value v_gnInd { // Receive a CAM message
        v_gnAddr := v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector.gnAddr;
        v_getFirstCam := true;
          // Re-send CAM message to the other EUTs
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          repeat;
        }
        [] geoNetworkingPort.receive(
                                     mw_geoNwInd(
                                                 mw_geoNwPdu(
                                                             mw_geoNwShbPacketWithNextHeaderAndPayload(
                                                                                                       mw_longPosVectorAny(
                                                                                                                           ? /* FIXME complement(
                                                                                                                                v_gnAddr
                                                                                                                                )*/),
                                                                                                       ?,
                                                                                                       e_btpB,
                                                                                                       ?/*mw_cam_stationId(
                                                                                                          -,
                                                                                                          PX_EUT_DESC[p_eut_id].stationId
                                                                                                          )*/
                                                                                                       )))) -> value v_gnInd { // Receive a CAM message
          // Re-send CA message to the other EUTs
          eutGeoNetworkingPort.send(
                                    m_forward_geoNetworkingInd(
                                                               v_gnInd
                                                               ));
          tc_wait.stop;
          log("*** " & testcasename() & ": INFO: GN duplicated address conflict resolved ***");
          hmiPort.clear;
        }
        [] tc_wait.timeout {
          log("*** " & testcasename() & ": INCONC: GN duplicate address conflict scenario is incomplete ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
        }
      } // End of 'alt' statement
      tc_ac.start;
      alt { // Check neighbours
        [] hmiPort.receive(
                           HmiNeighborEventInds:?
                           ) -> value v_hmiNeighborEventInds {
          var boolean v_found := false;
          tc_ac.stop;
          for (var integer v_i := 0; v_i < lengthof(v_hmiNeighborEventInds); v_i := v_i + 1) {
            if (
                (PX_EUT_DESC[p_eut_id_neighbour].mid == v_hmiNeighborEventInds[v_i].mid) and 
                (PX_EUT_DESC[p_eut_id_neighbour].stationId == v_hmiNeighborEventInds[v_i].stationId)
                ) {
            v_found := true;
              break; // Got it, leave the loop
            } // else, continue
          } // End of 'for' statement
          if (v_found) {
            log("*** " & testcasename() & ": PASS: GN duplicate address conflict scenario compeleted for EUT ", PX_EUT_DESC[p_eut_id].stationId, "***");
            f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
          } else {
            log("*** " & testcasename() & ": FAIL: GN duplicate address conflict scenario is incomplete ***");
            f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
          }
        }
        [] tc_ac.timeout {
          log("*** " & testcasename() & ": FAIL: Expected message not received ***");
          f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
        }
      }
            
      // Postamble
      f_poDefault();
      f_cfPtcDown(p_eut);
            
    } // End of f_TC_AUTO_IOT_GN_DAD_BV_01_eut
        
  } // End of group g_TC_AUTO_IOT_GN_DAD_BV_01 
    
} // End of module AtsInterop_TestCases 
