ItsAutoInterop_TestCases.ttcn

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;
    
    
    // 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;
    
    // LibItsGeoNetworking
    import from LibItsDenm_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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                mw_longPosVector_targetArea(
                                    PICS_TARGET_GEOAREA.latitude,
                                    PICS_TARGET_GEOAREA.longitude
                                ),
                                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;
            
            // 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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                e_btpB,
                                mw_denm_stationId(
                                    PX_EUT_DESC[p_eut_id].stationId,
                                    mw_denm(
                                        mw_denmMgmtCon_with_relevances(
                                            ?, 
                                            LibItsCommon_ASN1_NamedNumbers.StationType_roadSideUnit_,
                                            -,
                                            -,
                                            -,
                                            -,
                                            -,
                                            -
                                        ),
                                        mw_situation(
                                            LibItsCommon_ASN1_NamedNumbers.CauseCodeType_roadworks_, 
                                            ?
                ))))))) -> 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
                    ));
                    tc_ac.start;
                    repeat;
                }
                [] tc_ac.timeout {
                    log("*** " & testcasename() & ": PASS: Test done ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                }
            } // End of 'alt' statement
            
            // 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 EutGeoNetworking v_eutGeoNw;
            var HmiSignageEventInd v_hmiSignageEventInd;
            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
            
            // Test component configuration
            f_cfPtcUp(p_eut);
            
            // Preamble
            f_prDefault();
            // Wait for EUT_1 DEN messages
            v_counter := 0;
            tc_ac.start;
            alt {
                [] eutGeoNetworkingPort.receive(
                    mw_eutGeoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                e_btpB,
                                mw_denm_stationId(
                                    ?,
                                    mw_denm(
                                      mw_denmMgmtCon_with_relevances(
                                          ?, 
                                          -,
                                          -,
                                          -,
                                          -,
                                          -,
                                          -,
                                          -
                                      ),
                                      mw_situation(
                                          LibItsCommon_ASN1_NamedNumbers.CauseCodeType_roadworks_, 
                                          ?
                ))))))) -> value v_eutGeoNw { // Receive a DEN message
                    tc_ac.stop;
                    v_counter := v_counter + 1;
                    if (v_counter < 3) {
                        tc_ac.start;
                    } else {
                        log("*** " & testcasename() & ": INFO: EUT2 (vehicle) receives RWW DENMs D1, D2 and D3 ***");
                        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 {
                [] eutGeoNetworkingPort.receive(
                    mw_eutGeoNwInd_withLinkLayerDestination(
                        mw_geoNwPdu(
                            mw_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                e_btpB, 
                                mw_cam_stationId(
                                    -,
                                    PX_EUT_DESC[p_eut_id].stationId
                         ))),
                         c_llBroadcast
                )) -> value v_eutGeoNw { 
                    // Compute distance from v_nextPosition2reach
                    v_distance := f_distance(
                                             v_eutGeoNw.msg.gnPacket.packet.extendedHeader.shbHeader.srcPosVector,
                                             valueof(m_longPosVector(v_nextPosition2reach))
                    );
                    select (v_isOnPosition) {
                      case (-1) {
                        if (v_distance <= PX_PRE_DEFINED_SECURITY_DISTANCE) { // Position PICS_POS1 was reached
                            v_isOnPosition := 0;
                            v_nextPosition2reach := PICS_POS1;
                            tc_noac.start;
                        }
                      }
                      case (0) {
                        if (v_distance <= PX_PRE_DEFINED_SECURITY_DISTANCE) { // Position PICS_POS2 was reached
                            v_isOnPosition := 1;
                            v_nextPosition2reach := PICS_POS2;
                            tc_noac.start;
                        }
                      }
                      case (1) {
                        if (v_distance <= PX_PRE_DEFINED_SECURITY_DISTANCE) { // Position PICS_POS3 was reached
                            v_isOnPosition := 2;
                            v_nextPosition2reach := PICS_POS3;
                            tc_noac.start;
                        }
                      }
                      case (2) {
                        if (v_distance <= PX_PRE_DEFINED_SECURITY_DISTANCE) { // Position PICS_POS4 was reached
                            v_isOnPosition := 3;
                            v_nextPosition2reach := PICS_POS4;
                            tc_noac.start;
                        }
                      }
                      case else {
                        tc_noac.start;
                      }
                    } // End of 'select' statement
                    repeat;
                }
                [v_isOnPosition == 0] hmiPort.receive(
                    mw_hmiSignageEventInd_roadworks_limitedspeed 
                ) -> value v_hmiSignageEventInd {
                    log("*** " & testcasename() & ": INFO: EUT2 reaches position ", v_isOnPosition, " ***");
                    tc_noac.stop;
                    repeat; // Continue
                }
                [v_isOnPosition == 1] hmiPort.receive(
                    HmiSignageEventInd:?/*TODO*/
                ) -> value v_hmiSignageEventInd {
                    log("*** " & testcasename() & ": INFO: EUT2 reaches position ", v_isOnPosition, " ***");
                    tc_noac.stop;
                    repeat; // Continue
                }
                [v_isOnPosition == 2] hmiPort.receive(
                    HmiSignageEventInd:?/*TODO*/
                ) -> value v_hmiSignageEventInd {
                    log("*** " & testcasename() & ": INFO: EUT2 reaches position ", v_isOnPosition, " ***");
                    tc_noac.stop;
                    repeat; // Continue
                }
                [v_isOnPosition == 3] hmiPort.receive(
                    HmiSignageEventInd:?/*TODO*/
                ) -> value v_hmiSignageEventInd {
                    log("*** " & testcasename() & ": PASS: Road Works Warning scenario complete ***");
                    tc_noac.stop;
                    repeat; // Continue
                }
                [] tc_noac.timeout {
                    log("*** " & testcasename() & ": FAIL: Road Works Warning scenario failure in position ", v_isOnPosition, " ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                }
                [] tc_wait.timeout {
                    log("*** " & testcasename() & ": INCONC: Road Works Warning scenario is incomplet ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
                }
             } // End of 'alt' statement
            
            // Postamble
            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();
            // Nothing to do
            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            
            // Test Body
            tc_ac.start;
            alt {
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                e_btpB,
                                mw_denm_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
                    ));
                    tc_ac.start;
                    repeat;
                }
                [] tc_ac.timeout {
                    log("*** " & testcasename() & ": PASS: Test done ***");
                    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_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 EutGeoNetworking v_eutGeoNw;
            var float v_distance;
            
            // 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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                e_btpB,
                                mw_denm_stationId(
                                    PX_EUT_DESC[PX_EUT1_ID].stationId,
                                    mw_denm(
                                        mw_denmMgmtCon_with_relevances(
                                            mw_anyActionId, 
                                            -,
                                            -,
                                            -,
                                            -,
                                            -,
                                            lessThan100m,
                                            allTrafficDirections
                                        ),
                                        mw_situation(
                                            PX_DENM_CAUSE_VA, 
                                            PX_DENM_SUBCAUSE_VA
                ))))))) { 
                    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 {
                [] eutGeoNetworkingPort.receive(
                    mw_eutGeoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                e_btpB,
                                mw_cam_stationId(
                                    -,
                                    PX_EUT_DESC[p_eut_id].stationId
                ))))) -> value v_eutGeoNw { // Receive a DEN message
                    tc_ac.stop;
                    // Compute distance from POS0
                    v_distance := f_distance(
                                             v_eutGeoNw.msg.gnPacket.packet.extendedHeader.shbHeader.srcPosVector,
                                             valueof(m_longPosVector(PICS_POS0))
                    );
                    if (v_distance <= PX_LATERAL_COLLISION_SECURITY_DISTANCE) { // Position PICS_POS0 was reached
                        log("*** " & testcasename() & ": INFO: EUT2 has reached POS0 ***");
                    } else {
                        // Continue
                        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 { // EUT2 already indicates the Road Hazard Signal information 
                [] 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() & ": FAIL: Expected Road Hazard Signal information signage was not received ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                }
            }
            
            // 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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                e_btpB,
                                mw_denm_stationId(
                                    PX_EUT_DESC[p_eut_id].stationId,
                                    mw_denm(
                                        mw_denmMgmtCon_with_relevances(
                                            ?, 
                                            -,
                                            -,
                                            -,
                                            -,
                                            -,
                                            lessThan100m,
                                            allTrafficDirections
                                        ),
                                        mw_situation(
                                            PX_DENM_CAUSE_VA, 
                                            PX_DENM_SUBCAUSE_VA
                ))))))) -> 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
                    ));
                    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
            // 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 EutGeoNetworking v_eutGeoNw;
            var float v_distance;
            
            // 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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                e_btpB,
                                mw_denm_stationId(
                                    PX_EUT_DESC[PX_EUT1_ID].stationId,
                                    mw_denm(
                                        mw_denmMgmtCon_with_relevances(
                                            mw_anyActionId, 
                                            -,
                                            -,
                                            -,
                                            -,
                                            -,
                                            lessThan100m,
                                            allTrafficDirections
                                        ),
                                        mw_situation(
                                            PX_DENM_CAUSE_VA, 
                                            PX_DENM_SUBCAUSE_VA
                ))))))) { // 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 {
                [] eutGeoNetworkingPort.receive(
                    mw_eutGeoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                e_btpB,
                                mw_cam_stationId(
                                    -,
                                    PX_EUT_DESC[p_eut_id].stationId
                ))))) -> value v_eutGeoNw { 
                    tc_ac.stop;
                    // Compute distance from POS0
                    v_distance := f_distance(
                                             v_eutGeoNw.msg.gnPacket.packet.extendedHeader.shbHeader.srcPosVector,
                                             valueof(m_longPosVector(PICS_POS0))
                    );
                    if (v_distance <= PX_PRE_DEFINED_SECURITY_DISTANCE) { // Position PICS_POS0 was reached
                        log("*** " & testcasename() & ": INFO: EUT2 has reached POS0 ***");
                    } else {
                        // Continue
                        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 { // EUT2 already indicates the Stationary Vehicle Warning information 
                [] 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() & ": FAIL: Expected Stationary Vehicle Warning information was not received ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
                }
            }
            
            // 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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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
            ItsAutoInterop_Functions.f_utTriggerEvent(UtAutoInteropTrigger:{utRadioOnOff := true});
            tc_ac.start;
             alt {
                [] eutGeoNetworkingPort.receive(
                    mw_eutGeoNwInd_withLinkLayerDestination(
                        mw_geoNwPdu(
                            mw_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                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 LongPosVector v_myPosition;
            var float v_distance;
            
            // 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_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                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 := v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector;
                }
                [] geoNetworkingPort.receive( // TODO Move to default
                    mw_geoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwShbPacketWithNextHeader_cam
                ))) {
                    tc_ac.stop;
                    tc_ac.start;
                    repeat;
                }
                [] eutGeoNetworkingPort.receive( // TODO Move to default
                    mw_eutGeoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwShbPacketWithNextHeader_cam
                ))) {
                    tc_ac.stop;
                    tc_ac.start;
                    repeat;
                }
                [] geoNetworkingPort.receive( // TODO Move to default
                    mw_geoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                e_btpB,
                                mw_denm_stationId
                )))) {
                    tc_ac.stop;
                    tc_ac.start;
                    repeat;
                }
                [] eutGeoNetworkingPort.receive( // TODO Move to default
                    mw_eutGeoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwTsbPacketWithNextHeader_denm(
                                ?,
                                ?,
                                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_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                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 := v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector;
                }
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwPdu(
                            mw_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                e_btpB,
                                mw_cam_stationId
                )))) -> value v_gnInd { // Receive a DEN message
                    tc_ac.stop;
                    // Re-send CA message to the other EUTs
                    eutGeoNetworkingPort.send(
                                              m_forward_geoNetworkingInd(
                                                  v_gnInd
                    ));
                    // Store my current position
                    v_distance := f_distance(
                                             v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector,
                                             valueof(v_myPosition)
                    );
                    if (v_distance >= PX_FORWARD_COLLISION_SECURITY_DISTANCE) { // TODO Check elevation
                        tc_ac.start;
                        repeat;
                    } // else, nothing to do
                }
                [] 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;
            
            // 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_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                e_btpB,
                                mw_cam_stationId(
                                    -,
                                    PX_EUT_DESC[p_eut_id].stationId
                ))))) -> value v_gnInd { // Receive a DEN message
                    tc_ac.stop;
                    // Re-send CA message to the other EUTs
                    eutGeoNetworkingPort.send(
                                              m_forward_geoNetworkingInd(
                                                  v_gnInd
                    ));
                    // Compute distance from POS3
                    v_distance := f_distance(
                                             v_gnInd.msgIn.gnPacket.packet.extendedHeader.shbHeader.srcPosVector,
                                             valueof(m_longPosVector(PICS_POS3))
                    );
                    if (v_distance >= PX_LATERAL_COLLISION_SECURITY_DISTANCE) { // TODO Check elevation
                        // Continue
                        tc_ac.start;
                        repeat;
                    } // else, nothing to do
                }
                [] 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
            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_geoNwShbPacketWithNextHeader_cam(
                                ?,
                                ?,
                                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_geoNwShbPacketWithNextHeader_cam(
                                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