ItsAutoInterop_TestCases.ttcn

        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);