ItsAutoInterop_TestCases.ttcn

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