/**
 *    @author     ETSI / STF421
 *    @version    $URL: svn+ssh://vcs.etsi.org/TTCN3/ATS/Its/trunk/ttcn/AtsDCC/ItsDcc_TestCases.ttcn $
 *                $Id: ItsDcc_TestCases.ttcn 372 2012-06-12 10:00:36Z tepelmann $
 *    @desc       DCC Testcases (TP version: 0.0.10)
 *
 */

module ItsDcc_TestCases {
    
    // LibCommon
    import from LibCommon_Sync all;
    import from LibCommon_VerdictControl all;
    import from LibCommon_Time all;
    
    // LibIts
    import from LibItsCommon_Functions all;
    import from LibItsCommon_TestSystem all;
    import from LibItsDcc_TestSystem all;
    import from LibItsDcc_Functions all;
    import from LibItsDcc_Templates all;
    import from LibItsDcc_Pixits all;
    import from LibItsDcc_TypesAndValues all;
    import from LibItsDcc_Pics {modulepar all};
    
    group SingleTransceiverITSStation { // 5.2.1
    
        group CCH_relaxed_channel_state { // 5.2.1.1
        
            /**
             * @desc Verify that the single transceiver IUT can correctly send frames with priority VAL_DP
             *       at a rate of VAL_Message_Interval on the CCH in state relaxed when PTx < PCCH_rel.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Relaxed
             *     PCCH_rel = PICS A.5/1
             *     PTx = PIXIT_PTx
             *     PTx < PCCH_rel
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = PIXIT_PTx < PCCH_rel,
             *     transmits the frames on the CCH
             *         with PTx = PIXIT_PTx and 
             *         Toff = VAL_Toff
             *     sends on the PCO_IN IN_Status ASPs indicating
             *         channel = CCH,
             *         successful transmission,
             *         achieved PTx = PIXIT_PTx.
             * </pre>
             * 
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_REL_01(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(relaxed));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RELAXED, p_aspect.profile, cCH));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RELAXED, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_REL_01
            
            /**
             * @desc Verify that the single transceiver IUT can reduce the transmit power on the CCH in state relaxed when
             *       PTx > PCCH_rel and can report this power reduction to the upper layer
             * @param p_aspect
             * @verdict 
             * <pre>
             * PICS Selection: A.2/1
             * Initial conditions:
             *     CCH = Relaxed
             *     PCCH_rel = PICS A.5/1
             *     PTx = PIXIT_PTx
             *     PTx < PCCH_rel
             * Expected behaviour: 
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = PIXIT_PTx  > PCCH_rel,
             *     transmits the frames on the CCH
             *         with PTx = PCCH_rel and 
             *         Toff = VAL_Toff
             *     sends on the PCO_IN IN_Status ASPs indicating
             *         channel = CCH,
             *         successful transmission,
             *         achieved PTx = PCCH_rel
             * </pre>
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_REL_02(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(relaxed));
                
                // Start test components
                vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_CCH_RELAXED, p_aspect.profile, cCH, PICS_MAXPOWER_CCH_RELAXED));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_CCH_RELAXED, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_REL_02
            
            /**
             * @desc Verify that the single transceiver IUT can report unsuccessful sending of frames on the CCH in 
             *       state relaxed when the request frame rate is higher than the maximum allowed 
             *       VAL_Message_Interval.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Relaxed
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the active state,
             *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = acceptable PTx value,
             *     transmits frames on the CCH with
             *         Toff = VAL_Toff
             *     and drops the remaining frames
             *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
             *         channel = CCH,
             *         successful transmission
             *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
             *         unsuccessful transmission.
             * </pre>
             * 
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_REL_03(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(relaxed));
                
                // Start test components
                // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_CCH_RELAXED, p_aspect.profile, cCH));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RELAXED, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_REL_03
            
            /**
             * @desc Verify that the single transceiver IUT drops frames with priority values above DP8 on the CCH
             *       in state relaxed.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Relaxed
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of an IN_Request ASP,
             *         containing a payload and indicating
             *         DP# in the range between 9 and 32,
             *     drops the frame and does not transmit it,
             *     sends on the PCO_IN an IN_Status ASP indicating
             *         unsuccessful transmission.
             * </pre>
             * 
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_REL_04() runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var float v_tOff := 0.500;
                var integer v_dpx := float2int(int2float(32 - 9 +1)*rnd()) + 9; //random DP# in the range between 9 and 32
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(relaxed));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_RELAXED, v_dpx));
                vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_REL_04
            
        } // end group CCH_active_channel_state
        
        group CCH_active_channel_state { // 5.2.1.1
        
            /**
             * @desc Verify that the single transceiver IUT can correctly send frames with priority VAL_DP
             *       at a rate of VAL_Message_Interval on the CCH in state active when PTx < PCCH_rel.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Active
             *     PCCH_rel = PICS A.5/2
             *     PTx = PIXIT_PTx
             *     PTx < PCCH_rel
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = PIXIT_PTx < PCCH_rel,
             *     transmits the frames on the CCH
             *         with PTx = PIXIT_PTx and 
             *         Toff = VAL_Toff
             *     sends on the PCO_IN IN_Status ASPs indicating
             *         channel = CCH,
             *         successful transmission,
             *         achieved PTx = PIXIT_PTx.
             * </pre>
             * 
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_ACT_01(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, p_aspect.profile, cCH));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_ACT_01
            
            /**
             * @desc Verify that the single transceiver IUT can reduce the transmit power on the CCH in state active when
             *       PTx > PCCH_rel and can report this power reduction to the upper layer
             * @param p_aspect
             * @verdict 
             * <pre>
             * PICS Selection: A.2/1
             * Initial conditions:
             *     CCH = Active
             *     PCCH_rel = PICS A.5/2
             *     PTx = PIXIT_PTx
             *     PTx < PCCH_rel
             * Expected behaviour: 
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = PIXIT_PTx  > PCCH_rel,
             *     transmits the frames on the CCH
             *         with PTx = PCCH_rel and 
             *         Toff = VAL_Toff
             *     sends on the PCO_IN IN_Status ASPs indicating
             *         channel = CCH,
             *         successful transmission,
             *         achieved PTx = PCCH_rel
             * </pre>
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_ACT_02(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active));
                
                // Start test components
                vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_CCH_ACTIVE, p_aspect.profile, cCH, PICS_MAXPOWER_CCH_ACTIVE));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_CCH_ACTIVE, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_ACT_02
            
            /**
             * @desc Verify that the single transceiver IUT can report unsuccessful sending of frames on the CCH in 
             *       state active when the request frame rate is higher than the maximum allowed 
             *       VAL_Message_Interval.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Active
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the active state,
             *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = acceptable PTx value,
             *     transmits frames on the CCH with
             *         Toff = VAL_Toff
             *     and drops the remaining frames
             *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
             *         channel = CCH,
             *         successful transmission
             *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
             *         unsuccessful transmission.
             * </pre>
             * 
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_ACT_03(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active));
                
                // Start test components
                // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, p_aspect.profile, cCH));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_ACT_03
            
            /**
             * @desc Verify that the single transceiver IUT drops frames with priority values above DP8 on the CCH
             *       in state active.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Active
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of an IN_Request ASP,
             *         containing a payload and indicating
             *         DP# in the range between 9 and 32,
             *     drops the frame and does not transmit it,
             *     sends on the PCO_IN an IN_Status ASP indicating
             *         unsuccessful transmission.
             * </pre>
             * 
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_ACT_04() runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var float v_tOff := 0.500;
                var integer v_dpx := float2int(int2float(32 - 9 +1)*rnd()) + 9; //random DP# in the range between 9 and 32
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, v_dpx));
                vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_ACT_04
            
        } // end group CCH_active_channel_state
        
        group CCH_restrictive_channel_state { // 5.2.1.1
        
            /**
             * @desc Verify that the single transceiver IUT can correctly send frames with priority VAL_DP
             *       at a rate of VAL_Message_Interval on the CCH in state restrictive when PTx < PCCH_rel.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Restrictive
             *     PCCH_rel = PICS A.5/2
             *     PTx = PIXIT_PTx
             *     PTx < PCCH_rel
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = PIXIT_PTx < PCCH_rel,
             *     transmits the frames on the CCH
             *         with PTx = PIXIT_PTx and 
             *         Toff = VAL_Toff
             *     sends on the PCO_IN IN_Status ASPs indicating
             *         channel = CCH,
             *         successful transmission,
             *         achieved PTx = PIXIT_PTx.
             * </pre>
             * 
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_RES_01(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, cCH));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_RES_01
            
            /**
             * @desc Verify that the single transceiver IUT can reduce the transmit power on the CCH in state restrictive when
             *       PTx > PCCH_rel and can report this power reduction to the upper layer
             * @param p_aspect
             * @verdict 
             * <pre>
             * PICS Selection: A.2/1
             *     Initial conditions:
             *     CCH = Restrictive
             *     PCCH_rel = PICS A.5/2
             *     PTx = PIXIT_PTx
             *     PTx < PCCH_rel
             * Expected behaviour: 
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = PIXIT_PTx  > PCCH_rel,
             *     transmits the frames on the CCH
             *         with PTx = PCCH_rel and 
             *         Toff = VAL_Toff
             *     sends on the PCO_IN IN_Status ASPs indicating
             *         channel = CCH,
             *         successful transmission,
             *         achieved PTx = PCCH_rel
             * </pre>
             * @see  ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_RES_02(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive));
                
                // Start test components
                vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, cCH, PICS_MAXPOWER_CCH_RESTRICTIVE));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_CCH_RESTRICTIVE, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_RES_02
            
            /**
             * @desc Verify that the single transceiver IUT can report unsuccessful sending of frames on the CCH in 
             *       state restrictive when the request frame rate is higher than the maximum allowed 
             *       VAL_Message_Interval.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Restrictive
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the active state,
             *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
             *         containing a payload and indicating
             *         DP# = VAL_DP,
             *         PTx = acceptable PTx value,
             *     transmits frames on the CCH with
             *         Toff = VAL_Toff
             *     and drops the remaining frames
             *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
             *         channel = CCH,
             *         successful transmission
             *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
             *         unsuccessful transmission.
             * </pre>
             * 
             * @see ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_RES_03(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive));
                
                // Start test components
                // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, cCH));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, cCH));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_RES_03
            
            /**
             * @desc Verify that the single transceiver IUT drops frames with priority values above DP8 on the CCH
             *       in state restrictive.
             * <pre>
             * Pics Selection: A.2/1
             * Initial conditions: 
             *     CCH = Restrictive
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the relaxed state,
             *     on receipt of an IN_Request ASP,
             *         containing a payload and indicating
             *         DP# in the range between 9 and 32,
             *     drops the frame and does not transmit it,
             *     sends on the PCO_IN an IN_Status ASP indicating
             *         unsuccessful transmission.
             * </pre>
             * 
             * @see ETSI TS 102 724 clause 5.4.3.2, table 1
             */
            testcase TC_STS_RES_04() runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var float v_tOff := 0.500;
                var integer v_dpx := float2int(int2float(32 - 9 +1)*rnd()) + 9; //random DP# in the range between 9 and 32
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, v_dpx));
                vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_STS_RES_04
            
        } // end group CCH_restrictive_channel_state
        
    } // end group SingleTransceiverITSStation

    group MultipleTransceiverITSStation_G5A {
        group CCH_related {
            group CCH_variable_channel_states {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can drop frames with priority VAL_DP when the request 
                 *       frame rate is higher than the maximum allowed VAL_Message_Interval of the CCH 
                 *       in state VAL_State_CCH and with SCH1 in state VAL_State_SCH1.
                 * <pre>
                 * Pics Selection: A.2/2, A.4/2
                 * Initial conditions: 
                 *     CCH = VAL_State_CCH
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the VAL_State_CCH state and SCH1 in state VAL_State_SCH1,
                 *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         acceptable PTx value,
                 *     transmits frames on the CCH
                 *         Toff > VAL_Toff
                 *     and drops the remaining frames
                 *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *         channel = CCH,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * 
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 1, table 2
                 */
                testcase TC_MTS_CCH_01(ProfileSingleChannelTimeChannelAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", CCH state " & f_channelState2str(p_aspect.aspect.cchState) 
                        & ", Message Interval " & fx_float2str(p_aspect.aspect.aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.aspect.aspect.tOff) & "s"
                        & ", SCH1 state " & f_channelState2str(p_aspect.aspect.aspect.sch1State) 
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(p_aspect.aspect.cchState, p_aspect.aspect.aspect.sch1State));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.aspect.aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, cCH));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.aspect.aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, cCH));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_CCH_01
                
                /**
                 * @desc Verify that the multiple transceiver IUT can drop all frames for VAL_DP in the range between 5 
                 *       and 8 when CCH, SCH1 and SCH2 are in channel states other than the relaxed state.
                 * <pre>
                 * PICS Selection : A.2/2, A.4/2, A.4/3
                 * Initial Conditions: 
                 *     CCH = VAL_State_CCH
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = VAL_State_SCH2
                 * Expected behaviour: 
                 * Ensure that the IUT, with CCH, SCH1 and SCH2 in channel states other than the relaxed state,
                 *     on receipt of an IN_Request ASP,
                 *         containing a payload and indicating
                 *         DP# = VAL_DP in the range between 5 and 8,
                 *     drops the frame and does not transmit it,
                 *     sends on the PCO_IN an IN_Status ASP indicating
                 *         unsuccessful transmission.
                 * </pre>
                 *  @see ETSI TS 102 724 5.4.3.2, table 1, table 2, table 3
                 */
                testcase TC_MTS_CCH_02(ProfileSingleChannelAspect p_aspect)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(p_aspect.aspect.cchState, p_aspect.aspect.sch1State, p_aspect.aspect.sch2State));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_RELAXED, p_aspect.profile));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_CCH_02
                
            } // end group CCH_variable_channel_states
            
            group CCH_active_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority VAL_DP
                 *       on CCH and SCH1 when the request frame rate is higher than the maximum 
                 *       allowed VAL_Message_Interval of the CCH in state active and with SCH1 in state 
                 *       VAL_State_SCH1.
                 * <pre>
                 * Pics Selection: A.2/2 A.4/2
                 * Initial conditions: 
                 *     CCH = Active
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the active and SCH1 in state VAL_State_SCH1,
                 *     on receipt of IN_Request ASPs at a rate of rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP
                 *         acceptable PTx value,
                 *     transmits frames on the CCH
                 *         Toff > VAL_Toff
                 *     and transmits frames on the SCH1
                 *     sends on the PCO_IN IN_Status ASPs for CCH transmitted frames indicating
                 *         channel = CCH,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for SCH1 transmitted frames indicating
                 *         channel = SCH1,
                 *         successful transmission.
                 * </pre>
                 * 
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 1 and 2
                 */
                testcase TC_MTS_ACT_01(ProfileSingleTimeChannelAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.aspect.tOff) & "s"
                        & ", SCH1 state " & f_channelState2str(p_aspect.aspect.sch1State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active, p_aspect.aspect.sch1State));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSentOn2Channels(p_aspect.aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, p_aspect.profile, cCH, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSentOn2Channels(p_aspect.aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, cCH, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_ACT_01
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority DP4 at a rate of
                 *       2Hz on SCH1 in state VAL_State_SCH1 with CCH in state active.
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial Conditions: 
                 *     CCH = Active
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the active and SCH1 in state VAL_State_SCH1,
                 *     on receipt of IN_Request ASPs at a rate of 2Hz, each
                 *         containing a payload and indicating
                 *         DP# = DP4
                 *         acceptable PTx value,
                 *     transmits frames on the SCH1
                 *         Toff > 500ms
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 1 and 2
                 */
                testcase TC_MTS_ACT_02(ChannelState p_sch1State) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var ProfileType v_dpx := 4;
                    var float v_tOff := 0.500;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH1 state " & f_channelState2str(p_sch1State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active, p_sch1State));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, v_dpx, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_ACT_02
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority DP4 at a rate of 
                 *       2Hz on SCH2 in state VAL_State_SCH2 with CCH in state active and with SCH1 in state restrictive
                 * <pre>
                 * PICS Selection: A.2/2, A.4/3
                 * Initial conditions: 
                 *     CCH = Active
                 *     SCH1 = Restrictive
                 *     SCH2 = VAL_State_SCH2
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the active, SCH1 in the restrictive and SCH2 in state VAL_State_SCH2,
                 *     on receipt of IN_Request ASPs at a rate of 2Hz, each
                 *         containing a payload and indicating
                 *         DP# = DP4
                 *         acceptable PTx value,
                 *     transmits frames on the SCH2
                 *         Toff > 500ms
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH2,
                 *         successful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 1 and 2 
                 */
                testcase TC_MTS_ACT_03(ChannelState p_sch2State)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var ProfileType v_dpx := 4;
                    var float v_tOff := 0.500;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH2 state " & f_channelState2str(p_sch2State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active, restrictive, p_sch2State));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, v_dpx, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_ACT_03
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a 
                 *       rate of VAL_Message_Interval on the SCH1 in state relaxed with CCH in the active state.
                 * <pre>
                 * Initial conditions:
                 *     CCH = Active
                 *     SCH1 = Relaxed
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the active and SCH1 in the relaxed state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx =     acceptable PTx value,
                 *     transmits the frames on the SCH1 with
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_ACT_04(ProfileTimeAspect p_aspect)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_ACT_04
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a
                 *       rate of VAL_Message_Interval on the SCH2 in state relaxed with CCH in the active state and SCH1 in state VAL_State_SCH1.
                 * <prev>
                 * PICS Selection: A.2/2, A.4/3
                 * Initial conditions:
                 *     CCH = Active
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = Relaxed
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the active, SCH 1 in the VAL_State_SCH1 and SCH2 in the relaxed state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = acceptable PTx value,
                 *     transmits the frames on the SCH2 with
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH2,
                 *         successful transmission.
                 * </prev>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_ACT_05(ChannelState p_sch1State, ProfileTimeAspect p_aspect)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH1 state " & f_channelState2str(p_sch1State) 
                        & ", DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active, p_sch1State, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, p_aspect.profile, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_ACT_05
                
            } // end group CCH_active_channel_state
            
            group CCH_restrictive_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority VAL_DP on CCH and SCH1 when
                 *       the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 *       of the CCH in state restrictive and with SCH1 in state VAL_State_SCH1.
                 * <prev>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Restrictive
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the restrictive and SCH1 in state VAL_State_SCH1,
                 *     on receipt of IN_Request ASPs at a rate of rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP
                 *         acceptable PTx value,
                 *     transmits frames on the CCH
                 *         Toff = VAL_Toff
                 *     and transmits frames on the SCH1
                 *     sends on the PCO_IN IN_Status ASPs for CCH transmitted frames indicating
                 *         channel = CCH,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for SCH1 transmitted frames indicating
                 *         channel = SCH1,
                 *         successful transmission.
                 * </prev>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 1, table 2
                 */
                testcase TC_MTS_RES_01(ProfileSingleTimeChannelAspect p_aspect)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.aspect.tOff) & "s"
                        & ", SCH1 state " & f_channelState2str(p_aspect.aspect.sch1State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active, p_aspect.aspect.sch1State));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSentOn2Channels(p_aspect.aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, cCH, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSentOn2Channels(p_aspect.aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, cCH, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_RES_01
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority DP4
                 *       at a rate of 2Hz on SCH1 in state VAL_State_SCH1 with CCH in state restrictive.
                 * <prev>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Restrictive
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the restrictive and SCH1 in state VAL_State_SCH1,
                 *     on receipt of IN_Request ASPs at a rate of 2Hz, each
                 *         containing a payload and indicating
                 *         DP# = DP4
                 *         acceptable PTx value,
                 *     transmits frames on the SCH1
                 *         Toff > 500ms
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission.
                 * </prev>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 1, table 2
                 */
                testcase TC_MTS_RES_02(ChannelState p_sch1State)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var ProfileType v_dpx := 4;
                    var float v_tOff := 0.500;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH1 state " & f_channelState2str(p_sch1State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive, p_sch1State));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, v_dpx, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_RES_02
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority DP4
                 *       at a rate of 2Hz on SCH2 in state VAL_State_SCH2 with CCH and SCH1 in state restrictive.
                 * <prev>
                 * PICS Selection: A.2/2, A.4/3
                 * Initial conditions:
                 *     CCH = Restrictive
                 *     SCH1 = Restrictive
                 *     SCH2 = VAL_State_SCH2
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH and SCH1 in the restrictive and SCH2 in state VAL_State_SCH2,
                 *     on receipt of IN_Request ASPs at a rate of 2Hz, each
                 *         containing a payload and indicating
                 *         DP# = DP4
                 *         acceptable PTx value,
                 *     transmits frames on the SCH2
                 *         Toff > 500ms
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH2,
                 *         successful transmission.
                 * </prev>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 1, table 2
                 */
                testcase TC_MTS_RES_03(ChannelState p_sch2State)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var ProfileType v_dpx := 4;
                    var float v_tOff := 0.500;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH2 state " & f_channelState2str(p_sch2State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive, restrictive, p_sch2State));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, v_dpx, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_RES_03
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP
                 *       at a rate of VAL_Message_Interval on the SCH1 in state relaxed with CCH in the restrictive state.
                 * <prev>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions: 
                 *     CCH = Restrictive
                 *     SCH1 = Relaxed
                 *     SCH2 = Status irrelevant
                 * Expected behaviour: 
                 * Ensure that the IUT, with CCH in the restrictive and SCH1 in the relaxed state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx =     acceptable PTx value,
                 *     transmits the frames on the SCH1 with
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission.
                 * </prev>
                 * @see ETSI TS 102 724 clause 5.4.3.2 table 2
                 */
                testcase TC_MTS_RES_04(ProfileTimeAspect p_aspect)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_RES_04
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate of
                 *       VAL_Message_Interval on the SCH2 in state relaxed with CCH in the restrictive state and SCH1 in state VAL_State_SCH1.
                 * <prev>
                 * PICS Selection: A.2/2, A.4/3
                 * Initial conditions:
                 *     CCH = Restrictive
                 *     SCH1 = VAL_State_SCH1
                 *     SCH2 = Relaxed
                 * Expected behaviour:
                 * Ensure that the IUT, with CCH in the restrictive, SCH 1 in the VAL_State_SCH1 and SCH2 in the relaxed state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = acceptable PTx value,
                 *     transmits the frames on the SCH2 with
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH2,
                 *         successful transmission.
                 * </prev> 
                 * @see ETSI TS 102 724 clause 5.4.3.2 table 2
                 */
                testcase TC_MTS_RES_05(ChannelState p_sch1State, ProfileTimeAspect p_aspect)runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH1 state " & f_channelState2str(p_sch1State) 
                        & "DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive, p_sch1State, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_RES_05
                
            } // end group CCH_restrictive_channel_state
            
        } // end group CCH_related
        
        group SCH1_related {
            
            group SCH1_relaxed_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate of
                 *       VAL_Message_Interval on the SCH1 in state relaxed when PTx < PSCH1_rel.
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Relaxed
                 *     SCH2 = Status irrelevant
                 *     PSCH1_rel = PICS A.5/4
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH1_rel
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the relaxed state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx < PSCH1_rel,
                 *     transmits the frames on the SCH1
                 *         with PTx = PIXIT_PTx and 
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission,
                 *         achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2
                 */
                testcase TC_MTS_SCH1_01(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RELAXED, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RELAXED, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_01
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH1 in state relaxed
                 *       when PTx > PSCH1_rel and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions: 
                 *     CCH = Status irrelevant
                 *     SCH1 = Relaxed
                 *     SCH2 = Status irrelevant
                 *     PSCH1_rel = PICS A.5/4
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH1_rel
                 * Expected behaviour: 
                 * Ensure that the IUT, with SCH1 in the relaxed state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx  > PSCH1_rel,
                 *     transmits the frames on the SCH1
                 *         with PTx = PSCH1_rel and 
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission,
                 *         achieved PTx = PSCH1_rel.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2
                 */
                testcase TC_MTS_SCH1_02(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH1_RELAXED, p_aspect.profile, sCH1, PICS_MAXPOWER_SCH1_RELAXED));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH1_RELAXED, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_02
                
                /**
                 * 
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the
                 *       SCH1 in state relaxed when the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Relaxed
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the relaxed state,
                 *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP
                 *         PTx = acceptable PTx value,
                 *     transmits frames on the SCH1 with
                 *         Toff = VAL_Toff
                 *         and drops the remaining frames
                 *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *         channel = SCH1,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2
                 */
                testcase TC_MTS_SCH1_03(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, relaxed));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH1_RELAXED, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RELAXED, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_03
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP16 on the SCH1 in state relaxed.
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions: 
                 *     CCH = Status irrelevant
                 *     SCH1 = Relaxed
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the relaxed state,
                 *     on receipt of an IN_Request ASP,
                 *         containing a payload and indicating
                 *         DP# in the range between 17 and 32,
                 *         drops the frame and does not transmit it,
                 *     sends on the PCO_IN an IN_Status ASP indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_04() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 17 +1)*rnd()) + 17; //random DP# in the range between 17 and 32
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RELAXED, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_04
                
            } // end group SCH1_relaxed_channel_state
            
            group SCH1_active_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate of
                 *       VAL_Message_Interval on the SCH1 in state active when PTx < PSCH1_act.
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Active
                 *     SCH2 = Status irrelevant
                 *     PSCH1_act = PICS A.5/5
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH1_act
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the active state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx < PSCH1_act,
                 *     transmits the frames on the SCH1
                 *         with PTx = PIXIT_PTx and
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission,
                 *         achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_05(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_ACTIVE, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_ACTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_05
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH1
                 *       in state active when PTx > PSCH1_act and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Active
                 *     SCH2 = Status irrelevant
                 *     PSch1_act = PICS A.5/5
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH1_act
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the active state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx  > PSCH1_act,
                 *     transmits the frames on the SCH1
                 *         with PTx = PSCH1_act and 
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission,
                 *         achieved PTx = PSCH1_act.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_06(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH1_ACTIVE, p_aspect.profile, sCH1, PICS_MAXPOWER_SCH1_ACTIVE));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH1_ACTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_06
                
                /**
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on
                 *       the SCH1 in state active when the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Active
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the active state,
                 *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP
                 *         PTx = acceptable PTx value,
                 *     transmits frames on the SCH1 with
                 *         Toff = VAL_Toff
                 *         and drops the remaining frames
                 *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *         channel = SCH1,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_07(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, active));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH1_ACTIVE, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_ACTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_07
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP11 on the SCH1 in state active
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Active
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in state active,
                 *     on receipt of an IN_Request ASP,
                 *         containing a payload and indicating
                 *         DP# in the range between 12 and 32,
                 *     drops the frame and does not transmit it,
                 *     sends on the PCO_IN an IN_Status ASP indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_08() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 12 +1)*rnd()) + 12; //random DP# in the range between 12 and 32
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH1_ACTIVE, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } //TC_MTS_SCH1_08
                
            } // end group SCH1_active_channel_state
            
            group SCH1_restrictive_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP
                 *       at a rate of VAL_Message_Interval on the SCH1 in state restrictive when PTx < PSCH1_res.
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Restrictive
                 *     SCH2 = Status irrelevant
                 *     PSCH1_res = PICS A.5/6
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH1_res
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the restrictive state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx < PSCH1_res,
                 *     transmits the frames on the SCH1
                 *         with PTx = PIXIT_PTx and
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission,
                 *         achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_09(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RESTRICTIVE, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RESTRICTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Diconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_09
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH1 in state restrictive
                 *       when PTx > PSCH1_res and can report this power reduction to the upper layer
                 * <prev>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Restrictive
                 *     SCH2 = Status irrelevant
                 *     PSch1_res = PICS A.5/6
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH1_res
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the restrictive state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx  > PSCH1_res,
                 *     transmits the frames on the SCH1
                 *         with PTx = PSCH1_res and 
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH1,
                 *         successful transmission,
                 *         achieved PTx = PSCH1_res.
                 * </prev>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_10(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH1_RESTRICTIVE, p_aspect.profile, sCH1, PICS_MAXPOWER_SCH1_RESTRICTIVE));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH1_RESTRICTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Diconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_10
                
                /**
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the SCH1 in state
                 *       restrictive when the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 * <pre>
                 * PICS Selection: A.2/2, A.4/2
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Restrictive
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the restrictive state,
                 *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP
                 *         PTx = acceptable PTx value,
                 *     transmits frames on the SCH1 with
                 *         Toff = VAL_Toff
                 *         and drops the remaining frames
                 *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *         channel = SCH1,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_11(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH1_RESTRICTIVE, p_aspect.profile, sCH1));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RESTRICTIVE, sCH1));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_11
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP10 on the SCH1 in state restrictive.
                 * <pre>
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH1 = Restrictive
                 *     SCH2 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in state restrictive,
                 *     on receipt of an IN_Request ASP,
                 *         containing a payload and indicating
                 *         DP# in the range between 11 and 32,
                 *     drops the frame and does not transmit it,
                 *     sends on the PCO_IN an IN_Status ASP indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2 
                 */
                testcase TC_MTS_SCH1_12() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 11 +1)*rnd()) + 11; //random DP# in the range between 11 and 32
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH1_RESTRICTIVE, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH1_12
                
            } // end group SCH1_restrictive_channel_state
            
        } // end group SCH1_related
        
        group SCH2_related {
            
            group SCH2_relaxed_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate of
                 *       VAL_Message_Interval on the SCH2 in state relaxed when PTx < PSCH2_rel.
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Relaxed
                 *    PSCH2_rel = PICS A.5/7
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH2_rel
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH2 in the relaxed state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP,
                 *        PTx = PIXIT_PTx < PSCH2_rel,
                 *    transmits the frames on the SCH2
                 *        with PTx = PIXIT_PTx and 
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH2,
                 *        successful transmission,
                 *        achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 3 
                 */
                testcase TC_MTS_SCH2_01(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH2_RELAXED, p_aspect.profile, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH2_RELAXED, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_01
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH2 in state relaxed when
                 *       PTx > PSCH2_rel and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Relaxed
                 *    PSCH1_rel = PICS A.5/7
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH2_rel
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH2 in the relaxed state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP,
                 *        PTx = PIXIT_PTx  > PSCH2_rel,
                 *    transmits the frames on the SCH2
                 *        with PTx = PSCH2_rel and 
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH2,
                 *        successful transmission,
                 *        achieved PTx = PSCH2_rel.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 3 
                 */
                testcase TC_MTS_SCH2_02(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing :=
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile)
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz"
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH2_RELAXED, p_aspect.profile, sCH2, PICS_MAXPOWER_SCH2_RELAXED));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH2_RELAXED, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_02
                
                /**
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the SCH2 in state relaxed
                 *       when the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Relaxed
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH2 in the relaxed state,
                 *    on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP
                 *        PTx = acceptable PTx value,
                 *    transmits frames on the SCH2 with
                 *        Toff = VAL_Toff
                 *        and drops the remaining frames
                 *    sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *        channel = SCH2,
                 *        successful transmission
                 *        and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 3 
                 */
                testcase TC_MTS_SCH2_03(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, relaxed));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH2_RELAXED, p_aspect.profile, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH2_RELAXED, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_03
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP16 on the SCH2 in state relaxed.
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Relaxed
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH2 in the relaxed state,
                 *    on receipt of an IN_Request ASP,
                 *        containing a payload and indicating
                 *        DP# in the range between 17 and 32,
                 *    drops the frame and does not transmit it,
                 *    sends on the PCO_IN an IN_Status ASP indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 3 
                 */
                testcase TC_MTS_SCH2_04() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 17 +1)*rnd()) + 17; //random DP# in the range between 17 and 32
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH2_RELAXED, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_04
                
            } // end group SCH2_relaxed_channel_state
            
            group SCH2_active_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority DP11 at a rate of 0,1 Hz on the SCH2 in state active when PTx < PSCH2_act.
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Active
                 *    PSCH2_act = PICS A.5/8
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH2_act
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH2 in the active state,
                 *    on receipt of IN_Request ASPs at a rate of 0,1 Hz, each
                 *        containing a payload and indicating
                 *        DP# = DP11,
                 *        PTx = PIXIT_PTx < PSCH2_act,
                 *        transmits the frames on the SCH2
                 *        with PTx = PIXIT_PTx and 
                 *        Toff > 10 s
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH2,
                 *        successful transmission,
                 *        achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 3
                 */
                testcase TC_MTS_SCH2_05() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var integer v_dp := 11;
                    var float v_tOff := 10.000;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(v_dp) 
                        & ", Toff " & fx_float2str(v_tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH2_ACTIVE, v_dp, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH2_ACTIVE, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_05
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH2 in state active
                 *       when PTx > PSCH2_act and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Active
                 *    PSCH1_act = PICS A.5/7
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH2_act
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH2 in the active state,
                 *    on receipt of IN_Request ASPs at a rate of 0,1 Hz each
                 *        containing a payload and indicating
                 *        DP# = DP11,
                 *        PTx = PIXIT_PTx  > PSCH2_act,
                 *     transmits the frames on the SCH2
                 *        with PTx = PSCH2_act and 
                 *        Toff > 10 s
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH2,
                 *        successful transmission,
                 *        achieved PTx = PSCH2_act.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 3
                 */
                testcase TC_MTS_SCH2_06() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var integer v_dp := 11;
                    var float v_tOff := 10.000;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(v_dp) 
                        & ", Toff " & fx_float2str(v_tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(v_tOff, PIXIT_INACHIEVABLE_POWER_SCH2_ACTIVE, v_dp, sCH2, PICS_MAXPOWER_SCH2_ACTIVE));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PICS_MAXPOWER_SCH2_ACTIVE, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_06
                
                /**
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the SCH2 in state
                 *       active when the request frame rate is higher than the maximum allowed message interval of 0,1 Hz
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Active
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH2 in the active state,
                 *    on receipt of IN_Request ASPs at a rate higher than 0,1 Hz, each
                 *        containing a payload and indicating
                 *        DP# = DP11
                 *        PTx = acceptable PTx value,
                 *    transmits frames on the SCH2 with
                 *        Toff = 10 s
                 *        and drops the remaining frames
                 *    sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *        channel = SCH2,
                 *        successful transmission
                 *        and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *        unsuccessful transmission.
                 * </pre>
                 *  @see ETSI TS 102 724 clause 5.4.3.2, table 2
                 */
                testcase TC_MTS_SCH2_07() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var integer v_dp := 11;
                    var float v_tOff := 10.000;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(v_dp) 
                        & ", Toff " & fx_float2str(v_tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, active));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(v_tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH2_ACTIVE, v_dp, sCH2));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH2_ACTIVE, sCH2));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_07
                
                /**
                 * 
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the SCH2 in
                 *       state active when the request frame rate is higher than the maximum allowed message interval of 0,1 Hz.
                 * <pre>
                 * PICS Selection:    A.2/2, A.4/3
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH1 = Restrictive
                 *    SCH2 = Active
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH1 in the active state,
                 *    on receipt of an IN_Request ASP,
                 *        containing a payload and indicating
                 *        DP# in the range between 12 and 32,
                 *    drops the frame and does not transmit it,
                 *    sends on the PCO_IN an IN_Status ASP indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.4.3.2, table 2
                 */
                testcase TC_MTS_SCH2_08() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 12 +1)*rnd()) + 12; //random DP# in the range between 17 and 32
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, restrictive, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH2_ACTIVE, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_MTS_SCH2_08
                
            } // end group SCH2_active_channel_state
            
        } // end group SCH2_related
        
    } // end group MultipleTransceiverITSStation_G5A
    
    group MultipleTransceiverITSStation_G5B {
        
        group CCH_related {
            
            /**
             * @desc Verify that the multiple transceiver IUT can drop all frames with priority DP4 when CCH is in a channel state other than the relaxed state
             * <pre>
             * PICS Selection:    A.2/2, A.3/2
             * Initial conditions:
             *    CCH = VAL_State_CCH
             *    SCH3 = Status irrelevant
             *    SCH4 = Status irrelevant
             * Expected behaviour:
             * Ensure that the IUT, with CCH in state VAL_State_CCH,
             *    on receipt of an IN_Request ASP,
             *        containing a payload and indicating
             *        DP# = 4,
             *    drops the frame and does not transmit it,
             *    sends on the PCO_IN an IN_Status ASP indicating
             *        unsuccessful transmission.
             * </pre>
             * @see ETSI TS 102 724 clause 5.5.3, table 1, table 4, table 5
             */
            testcase TC_G5B_CCH_01(ChannelState p_cchState) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing CCH state " & f_channelState2str(p_cchState)
                    & ". ***";
                var float v_tOff := 0.500;
                var integer v_dpx := 4;
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(p_cchState));
                
                // Start test components
                log(v_testing);
                vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, f_getAcceptablePower(cCH, p_cchState), v_dpx));
                vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_G5B_CCH_01
            
            /**
             * @desc Verify that the multiple transceiver IUT can drop all frames with priority VAL_DP when CCH and SCH3 in channel states other than the relaxed state.
             * <pre>
             * PICS Selection:    A.2/2, A.3/2, A.4/4
             * Initial conditions:
             *    CCH = VAL_State_CCH
             *    SCH3 = VAL_State_SCH3
             *    SCH4 = Status irrelevant
             * Expected behaviour:
             * Ensure that the IUT, with CCH in state VAL_State_CCH and SCH3 in state VAL_State_SCH3,
             *    on receipt of an IN_Request ASP,
             *        containing a payload and indicating
             *        DP# = VAL_DP,
             *        drops the frame and does not transmit it,
             *    sends on the PCO_IN an IN_Status ASP indicating
             *        unsuccessful transmission.
             * </pre>
             * @see ETSI TS 102 724 clause 5.5.3, table 1, table 4, table 5
             */
            testcase TC_G5B_CCH_02(ProfileSingleChannelAspect2 p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var float v_tOff := 0.500;
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(p_aspect.aspect.cchState, -, -, p_aspect.aspect.sch3State));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, f_getAcceptablePower(cCH, p_aspect.aspect.cchState), p_aspect.profile));
                vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_G5B_CCH_02
            
            /**
             * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate of
             *       VAL_Message_Interval on the SCH3 in state VAL_State_SCH3 with CCH in the active state.
             * <pre>
             * Initial conditions:
             *    CCH = Active
             *    SCH3 = VAL_State_SCH3
             *    SCH4 = Status irrelevant
             * Expected behaviour:
             * Ensure that the IUT, with CCH in the active and SCH3 in the VAL_State_SCH3 state,
             *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *        containing a payload and indicating
             *        DP# = VAL_DP,
             *        PTx =     acceptable PTx value,
             *    transmits the frames on the SCH3 with
             *        Toff = VAL_Toff
             *    sends on the PCO_IN IN_Status ASPs indicating
             *        channel = SCH3,
             *        successful transmission.
             * </pre>
             * @see ETSI TS 102 724 clause 5.5.3, table 1, table 4
             */
            testcase TC_G5B_CCH_03(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing SCH3 state " & f_channelState2str(p_sch3State)
                    & ", DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(active, -, -, p_sch3State));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, p_aspect.profile, sCH3));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_ACTIVE, sCH3));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_G5B_CCH_03
            
            /**
             * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at
             *       a rate of VAL_Message_Interval on the SCH3 in state VAL_State_SCH3 with CCH in the restrictive state.
             * <pre>
             * PICS Selection:    A.2/2, A.3/2, A.4/4
             * Initial conditions:
             *    CCH = Restrictive
             *    SCH3 = VAL_State_SCH3
             *    SCH4 = Status irrelevant
             * Expected behaviour
             * Ensure that the IUT, with CCH in the restrictive and SCH3 in the VAL_State_SCH3 state,
             *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
             *        containing a payload and indicating
             *        DP# = VAL_DP,
             *        PTx =     acceptable PTx value,
             *    transmits the frames on the SCH3 with
             *        Toff = VAL_Toff
             *    sends on the PCO_IN IN_Status ASPs indicating
             *        channel = SCH3,
             *        successful transmission.
             * </pre>
             * @see ETSI TS 102 724 clause 5.5.3, table 1, table 4
             */
            testcase TC_G5B_CCH_04(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                
                // Local variables
                var charstring v_testing := 
                    "*** " & testcasename() & ": "
                    & "Testing SCH3 state " & f_channelState2str(p_sch3State)
                    & ", DP" & int2str(p_aspect.profile) 
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ". ***";
                
                // Create, connect, map test components
                f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(restrictive, -, -, p_sch3State));
                
                // Start test components
                vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, p_aspect.profile, sCH3));
                vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_CCH_RESTRICTIVE, sCH3));
                
                // Synchronize both PTCs on preamble synchronization point
                f_serverSyncClients(2, c_prDone);
                
                if (f_checkExpectedFrames() == e_success) {
                    setverdict(pass, v_testing);
                }
                else {
                    setverdict(fail, v_testing);
                }
                
                // Synchronize both PTCs on 2 synchronization points
                f_serverSyncNClientsAndStop(2, {c_tbDone});
                
                // Disconnect, unmap test components
                f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
            } // end TC_G5B_CCH_04
            
        } // end group CCH_related
        
        group SCH3_related {
            
            group SCH3_relaxed_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate
                 *       of VAL_Message_Interval on the SCH3 in state relaxed when PTx < PSCH3_rel.
                 * <pre>
                 * PICS Selection:	A.2/2, A.3/2, A.4/4
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH3 = Relaxed
                 *    SCH4 = Status irrelevant
                 *    PSCH3_rel = PICS A.5/10
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH3_rel
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the relaxed state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP,
                 *        PTx = PIXIT_PTx < PSCH3_rel,
                 *    transmits the frames on the SCH3
                 *        with PTx = PIXIT_PTx and 
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH3,
                 *        successful transmission,
                 *        achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_01(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RELAXED, p_aspect.profile, sCH3));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RELAXED, sCH3));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_01
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH3 in state relaxed
                 *       when PTx > PSCH3_rel and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection:    A.2/2, A.3/2, A.4/4
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH3 = Relaxed
                 *    SCH4 = Status irrelevant
                 *    PSCH3_rel = PICS A.5/10
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH3_rel
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the relaxed state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *       containing a payload and indicating
                 *       DP# = VAL_DP,
                 *       PTx = PIXIT_PTx  > PSCH3_rel,
                 *    transmits the frames on the SCH3
                 *        with PTx = PSCH3_rel and 
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH3,
                 *        successful transmission,
                 *        achieved PTx = PSCH3_rel.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_02(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH3_RELAXED, p_aspect.profile, sCH3, PICS_MAXPOWER_SCH3_RELAXED));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH3_RELAXED, sCH3));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_02
                
                /**
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the SCH3 in
                 *       state relaxed when the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 * <pre>
                 * PICS Selection:    A.2/2, A.3/2, A.4/4
                 * Initial conditions
                 *    CCH = Status irrelevant
                 *    SCH3 = Relaxed
                 *    SCH4 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the relaxed state,
                 *    on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP
                 *        PTx = acceptable PTx value,
                 *    transmits frames on the SCH3 with
                 *        Toff = VAL_Toff
                 *        and drops the remaining frames
                 *    sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *        channel = SCH3,
                 *        successful transmission
                 *    and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_03(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, relaxed));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH3_RELAXED, p_aspect.profile, sCH3));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RELAXED, sCH3));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Diconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_03
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP24 on the SCH3 in state relaxed.
                 * <pre>
                 * PICS Selection:    A.2/2, A.3/2, A.4/4
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH3 = Relaxed
                 *    SCH4 = Status irrelevant
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the relaxed state,
                 *    on receipt of an IN_Request ASP,
                 *        containing a payload and indicating
                 *        DP# in the range between 25 and 32,
                 *    drops the frame and does not transmit it,
                 *    sends on the PCO_IN an IN_Status ASP indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_04() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 25 +1)*rnd()) + 25; //random DP# in the range between 25 and 32
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RELAXED, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_04
                
            } // end group SCH3_relaxed_channel_state
            
            group SCH3_active_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate
                 *       of VAL_Message_Interval on the SCH3 in state active when PTx < PSCH3_act.
                 * <pre>
                 * PICS Selection:    A.2/2, A3/2 A.4/4
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH3 = Active
                 *    SCH4 = Status irrelevant
                 *    PSCH3_act = PICS A.5/11
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH3_act
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the active state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP,
                 *        PTx = PIXIT_PTx < PSCH3_act,
                 *    transmits the frames on the SCH3
                 *        with PTx = PIXIT_PTx and
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH3,
                 *        successful transmission,
                 *        achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_05(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_ACTIVE, p_aspect.profile, sCH3));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_ACTIVE, sCH3));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_05
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH3 in state active
                 *       when PTx > PSCH3_act and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection:    A.2/2, A3/2 A.4/4
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH3 = Active
                 *    SCH4 = Status irrelevant
                 *    PSCH3_act = PICS A.5/11
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH3_act
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the active state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP,
                 *        PTx = PIXIT_PTx  > PSCH3_act,
                 *    transmits the frames on the SCH3
                 *        with PTx = PSCH3_act and 
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH3,
                 *        successful transmission,
                 *        achieved PTx = PSCH3_act.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_06(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH3_ACTIVE, p_aspect.profile, sCH3, PICS_MAXPOWER_SCH3_ACTIVE));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH3_ACTIVE, sCH3));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_06
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority VAL_DP on SCH3
                 *       and SCH4 when the request frame rate VAL_Message_Interval is higher than the maximum allowed
                 *       VAL_Message_Interval of the SCH3 in state active and with SCH4 in state VAL_State_SCH4.
                 *  <pre>
                 * PICS Selection:    A.2/2, A3/2 A.4/4, A.4/5
                 * Initial conditions
                 *    CCH = Status irrelevant
                 *    SCH3 = Active
                 *    SCH4 = VAL_State_SCH4
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the active state,
                 *    on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP
                 *        PTx = acceptable PTx value,
                 *    transmits frames on the SCH3
                 *        Toff = VAL_Toff
                 *    and transmits frames on the SCH4
                 *    sends on the PCO_IN IN_Status ASPs for SCH3 transmitted frames indicating
                 *        channel = SCH3,
                 *        successful transmission
                 *    and sends on the PCO_IN IN_Status ASPs for SCH4 transmitted frames indicating
                 *        channel = SCH4,
                 *        successful transmission.
                 *  </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4, table 5
                 */
                testcase TC_G5B_SCH3_07(ChannelState p_sch4State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ", SCH4 state " & f_channelState2str(p_sch4State)
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, active, p_sch4State));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSentOn2Channels(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH3_ACTIVE, p_aspect.profile, sCH3, sCH4));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSentOn2Channels(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_ACTIVE, sCH3, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_07
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP24 on the SCH3 in state active.
                 * <pre>
                 * PICS Selection:    A.2/2, A3/2 A.4/4
                 * Initial conditions
                 *    CCH = Status irrelevant
                 *    SCH3 = Active
                 *    SCH4 = Status irrelevant
                 *    Expected behaviour
                 * Ensure that the IUT, with SCH3 in state active,
                 *    on receipt of an IN_Request ASP,
                 *        containing a payload and indicating
                 *        DP# in the range between 25 and 32,
                 *    drops the frame and does not transmit it,
                 *    sends on the PCO_IN an IN_Status ASP indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_08() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 25 +1)*rnd()) + 25; //random DP# in the range between 25 and 32
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH3_ACTIVE, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_08
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values between 11 and 16
                 *       and between 20 and 24 on the SCH3 in state active, when SCH4 is in state VAL_State_SCH4.
                 * <pre>
                 * PICS Selection:    A.2/2, A3/2 A.4/4
                 * Initial conditions
                 *    CCH = Status irrelevant
                 *    SCH3 = Active
                 *    SCH4 = VAL_State_SCH4
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in state active,
                 *    on receipt of an IN_Request ASP,
                 *        containing a payload and indicating
                 *        DP# in the range between 11 and 16 and between 20 and 24,
                 *    drops the frame and does not transmit it,
                 *    sends on the PCO_IN an IN_Status ASP indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_09(SingleChannelProfileAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, active, p_aspect.state));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH3_ACTIVE, p_aspect.profile));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_09
                
            } // end group SCH3_active_channel_state
            
            group SCH3_restrictive_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate
                 *       of VAL_Message_Interval on the SCH3 in state restrictive when PTx < PSCH3_res.
                 * <pre>
                 * PICS Selection:    A.2/2, A.3/2, A.4/4
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH3 = Restrictive
                 *    SCH4 = Status irrelevant
                 *    PSCH3_res = PICS A.5/12
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH3_res
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the restrictive state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP,
                 *        PTx = PIXIT_PTx < PSCH3_res,
                 *    transmits the frames on the SCH3
                 *        with PTx = PIXIT_PTx and
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH3,
                 *        successful transmission,
                 *        achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_10(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RESTRICTIVE, p_aspect.profile, sCH3));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RESTRICTIVE, sCH3));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_10
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH3
                 *       in state restrictive when PTx > PSCH3_res and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection:    A.2/2, A.3/2, A.4/4
                 * Initial conditions
                 *    CCH = Status irrelevant
                 *    SCH3 = Restrictive
                 *    SCH4 = Status irrelevant
                 *    PSCH3_res = PICS A.5/12
                 *    PTx = PIXIT_PTx
                 *    PTx < PSCH3_res
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the restrictive state,
                 *    on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP,
                 *        PTx = PIXIT_PTx  > PSCH3_res,
                 *    transmits the frames on the SCH3
                 *        with PTx = PSCH3_res and 
                 *        Toff = VAL_Toff
                 *    sends on the PCO_IN IN_Status ASPs indicating
                 *        channel = SCH3,
                 *        successful transmission,
                 *        achieved PTx = PSCH3_res.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_11(ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH3_RESTRICTIVE, p_aspect.profile, sCH3, PICS_MAXPOWER_SCH3_RESTRICTIVE));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH3_RESTRICTIVE, sCH3));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_11
                
                /**
                 * @desc Verify that the multiple transceiver IUT can transmit frames with priority VAL_DP on SCH3 and SCH4
                 *       when the request frame rate VAL_Message_Interval is higher than the maximum allowed VAL_Message_Interval
                 *       of the SCH3 in state restrictive and with SCH4 in state VAL_State_SCH4.
                 * <pre>
                 * PICS Selection:    A.2/2, A3/2 A.4/4, A.4/5
                 * Initial conditions:
                 *    CCH = Status irrelevant
                 *    SCH3 = Restrictive
                 *    SCH4 = VAL_State_SCH4
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH3 in the restrictive state,
                 *    on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *        containing a payload and indicating
                 *        DP# = VAL_DP
                 *        PTx = acceptable PTx value,
                 *    transmits frames on the SCH3
                 *        Toff = VAL_Toff
                 *    and transmits frames on the SCH4
                 *    sends on the PCO_IN IN_Status ASPs for SCH3 transmitted frames indicating
                 *        channel = SCH3,
                 *        successful transmission
                 *    and sends on the PCO_IN IN_Status ASPs for SCH4 transmitted frames indicating
                 *        channel = SCH4,
                 *        successful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4, table 5 
                 */
                testcase TC_G5B_SCH3_12(ChannelState p_sch4State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ", SCH4 state " & f_channelState2str(p_sch4State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, restrictive, p_sch4State));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSentOn2Channels(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH3_RESTRICTIVE, p_aspect.profile, sCH3, sCH4));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSentOn2Channels(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RESTRICTIVE, sCH3, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_12
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP24 on the SCH3 in state restrictive
                 * <pre>
                 * PICS Selection:	A.2/2, A.3/2, A.4/4
                 * Initial conditions
                 *    CCH = Status irrelevant
                 *    SCH3 = Restrictive
                 *    SCH4 = Status irrelevant
                 * Expected behaviour
                 * Ensure that the IUT, with SCH3 in state restrictive,
                 *    on receipt of an IN_Request ASP,
                 *        containing a payload and indicating
                 *        DP# in the range between 25 and 32,
                 *        drops the frame and does not transmit it,
                 *    sends on the PCO_IN an IN_Status ASP indicating
                 *       	unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_13() runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 25 +1)*rnd()) + 25; //random DP# in the range between 25 and 32
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RESTRICTIVE, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_13
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values between 11 and 16 and between 20 and 24
                 *       on the SCH3 in state restrictive, when SCH4 is in state VAL_State_SCH4.
                 * <pre>
                 * PICS Selection:    A.2/2, A3/2 A.4/4
                 * Initial conditions
                 *    CCH = Status irrelevant
                 *    SCH3 = Restrictive
                 *    SCH4 = VAL_State_SCH4
                 * Expected behaviour
                 * Ensure that the IUT, with SCH3 in state restrictive,
                 *    on receipt of an IN_Request ASP,
                 *        containing a payload and indicating
                 *        DP# in the range between 11 and 16 and between 20 and 24,
                 *    drops the frame and does not transmit it,
                 *    sends on the PCO_IN an IN_Status ASP indicating
                 *        unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 4
                 */
                testcase TC_G5B_SCH3_14(SingleChannelProfileAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, restrictive, p_aspect.state));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH3_RESTRICTIVE, p_aspect.profile));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                } // end TC_G5B_SCH3_14
                
            } // end group SCH3_restrictive_channel_state
            
        } // end group SCH3_related
        
        group SCH4_related {
            
            group SCH4_relaxed_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP on the SCH4 in state relaxed when PTx < PSCH4_rel.
                 * <pre>
                 * PICS Selection: A.2/2, A.3/2, A.4/5
                 * Initial conditions
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Relaxed
                 *     PSCH4_rel = PICS A.5/13
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH4_rel
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the relaxed and SCH3 in state VAL_State_SCH3,
                 *     on receipt of IN_Request ASPs, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx < PSCH4_rel,
                 *     transmits the frames on the SCH4
                 *         with PTx = PIXIT_PTx
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH4,
                 *         successful transmission,
                 *         achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_01(SingleChannelProfileAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH3 state " & f_channelState2str(p_aspect.state)
                        & ", DP" & int2str(p_aspect.profile)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_aspect.state, relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH4_RELAXED, p_aspect.profile, sCH4));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH4_RELAXED, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_01
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH4 in state relaxed
                 *       when PTx > PSCH4_rel and can report this power reduction to the upper layer.
                 * <pre>
                 * PICS Selection A.2/2, A.3/2, A.4/5
                 * Initial conditions
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Relaxed
                 *     PSCH4_rel = PICS A.5/13
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH4_rel
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the relaxed and SCH3 in state VAL_State_SCH3,
                 *     on receipt of IN_Request ASPs, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx  > PSCH4_rel,
                 *     transmits the frames on the SCH4
                 *         with PTx = PSCH4_rel
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH4,
                 *         successful transmission,
                 *         achieved PTx = PSCH4_rel.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_02(SingleChannelProfileAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var float v_tOff := 0.500;
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH3 state " & f_channelState2str(p_aspect.state)
                        & ", DP" & int2str(p_aspect.profile)
                        & ". ***";
                        
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_aspect.state,  relaxed));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(v_tOff, PIXIT_INACHIEVABLE_POWER_SCH4_RELAXED, p_aspect.profile, sCH4, PICS_MAXPOWER_SCH4_RELAXED));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(v_tOff, PICS_MAXPOWER_SCH4_RELAXED, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_02
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP24 on the SCH4 in state relaxed.
                 * <pre>
                 * PICS Selection: A.2/2, A.3/2, A.4/5
                 * Initial conditions
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Relaxed
                 * Expected behaviour
                 * Ensure that the IUT, with SCH4 in the relaxed and SCH4 in state VAL_State_SCH3,
                 *     on receipt of an IN_Request ASP,
                 *         containing a payload and indicating
                 *         DP# in the range between 25 and 32,
                 *     drops the frame and does not transmit it,
                 *     sends on the PCO_IN an IN_Status ASP indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_03(ChannelState p_sch3State) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH3 state " & f_channelState2str(p_sch3State)
                        & ". ***";
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 25 +1)*rnd()) + 25; //random DP# in the range between 25 and 32
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State, relaxed));
                    
                    // Start test components
                    log(v_testing);
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH4_RELAXED, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_03
                
            } // end group SCH4_relaxed_channel_state
            
            group SCH4_active_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate of
                 *       VAL_Message_Interval on the SCH4 in state active when PTx < PSCH4_act. 
                 * <pre>
                 * PICS Selection: A.2/2, A3/2 A.4/5
                 * Initial conditions
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Active
                 *     PSCH4_act = PICS A.5/14
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH4_act
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the active state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx < PSCH4_act,
                 *     transmits the frames on the SCH4
                 *         with PTx = PIXIT_PTx and
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH4,
                 *         successful transmission,
                 *         achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_04(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ", SCH3 state " & f_channelState2str(p_sch3State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State, active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH4_ACTIVE, p_aspect.profile, sCH4));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH4_ACTIVE, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_04
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH4 in
                 *       state active when PTx > PSCH4_act and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection: A.2/2, A3/2 A.4/5
                 * Initial conditions
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Active
                 *     PSCH4_act = PICS A.5/14
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH4_act
                 * Expected behaviour
                 * Ensure that the IUT, with SCH4 in the active state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx  > PSCH4_act,
                 *     transmits the frames on the SCH4
                 *         with PTx = PSCH4_act and 
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH4,
                 *         successful transmission,
                 *         achieved PTx = PSCH4_act.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_05(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ", SCH3 state " & f_channelState2str(p_sch3State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State,  active));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH4_ACTIVE, p_aspect.profile, sCH4, PICS_MAXPOWER_SCH4_ACTIVE));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH4_ACTIVE, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_05
                
                /**
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the SCH4
                 *       in state active when the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 * <pre>
                 * PICS Selection A.2/2, A3/2 A.4/5
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Active
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the active state,
                 *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP
                 *         PTx = acceptable PTx value,
                 *     transmits frames on the SCH4 with
                 *         Toff = VAL_Toff
                 *     and drops the remaining frames
                 *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *         channel = SCH4,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_06(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ", SCH3 state " & f_channelState2str(p_sch3State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State, active));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH4_ACTIVE, p_aspect.profile, sCH4));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH4_ACTIVE, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }// //end TC_G5B_SCH4_06
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP24 on the SCH4 in state active
                 * <pre>
                 * PICS Selection A.2/2, A3/2, A.4/5
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Active
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the active state,
                 *     on receipt of an IN_Request ASP,
                 *         containing a payload and indicating
                 *         DP# in the range between 25 and 32,
                 *     drops the frame and does not transmit it,
                 *     sends on the PCO_IN an IN_Status ASP indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_07(ChannelState p_sch3State) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH3 state " & f_channelState2str(p_sch3State)
                        & ". ***";
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 25 +1)*rnd()) + 25; //random DP# in the range between 25 and 32
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State, active));
                    
                    // Start test components
                    log(v_testing);
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH4_ACTIVE, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_07
                
            } // end group SCH4_active_channel_state
            
            group SCH4_restrictive_channel_state {
                
                /**
                 * @desc Verify that the multiple transceiver IUT can correctly send frames with priority VAL_DP at a rate
                 *       of VAL_Message_Interval on the SCH4 in state restrictive when PTx < PSCH4_res. 
                 * <pre>
                 * PICS Selection: A.2/2, A3/2 A.4/5
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Restrictive
                 *     PSCH4_res = PICS A.5/15
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH4_res
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the restrictive state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx < PSCH4_res,
                 *     transmits the frames on the SCH4
                 *         with PTx = PIXIT_PTx and
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH4,
                 *         successful transmission,
                 *         achieved PTx = PIXIT_PTx.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_08(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing :=
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile)
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz"
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ", SCH3 state " & f_channelState2str(p_sch3State)
                    & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_AllRequestedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH4_RESTRICTIVE, p_aspect.profile, sCH4));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH4_RESTRICTIVE, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_08
                
                /**
                 * @desc Verify that the multiple transceiver IUT can reduce the transmit power on the SCH4 in state restrictive
                 *       when PTx > PSCH4_res and can report this power reduction to the upper layer
                 * <pre>
                 * PICS Selection: A.2/2, A3/2 A.4/5
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Restrictive
                 *     PSCH4_res = PICS A.5/15
                 *     PTx = PIXIT_PTx
                 *     PTx < PSCH4_res
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the restrictive state,
                 *     on receipt of IN_Request ASPs at a rate of VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP,
                 *         PTx = PIXIT_PTx  > PSCH4_res,
                 *     transmits the frames on the SCH4
                 *         with PTx = PSCH4_res and 
                 *         Toff = VAL_Toff
                 *     sends on the PCO_IN IN_Status ASPs indicating
                 *         channel = SCH4,
                 *         successful transmission,
                 *         achieved PTx = PSCH4_res.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_09(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing DP" & int2str(p_aspect.profile) 
                        & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz" 
                        & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                        & ", SCH3 state " & f_channelState2str(p_sch3State)
                        & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -,p_sch3State, restrictive));
                    
                    // Start test components
                    vc_itsInDcc.start(f_iN_FramesSentTxPowerReduction(p_aspect.tOff, PIXIT_INACHIEVABLE_POWER_SCH4_RESTRICTIVE, p_aspect.profile, sCH4, PICS_MAXPOWER_SCH4_RESTRICTIVE));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PICS_MAXPOWER_SCH4_RESTRICTIVE, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }//end TC_G5B_SCH4_09
                
                /**
                 * @desc Verify that the multiple transceiver IUT can report unsuccessful sending of frames on the SCH4 in state
                 *       restrictive when the request frame rate is higher than the maximum allowed VAL_Message_Interval
                 * <pre>
                 * PICS Selection: A.2/2, A3/2 A.4/5
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Restrictive
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the restrictive state,
                 *     on receipt of IN_Request ASPs at a rate higher than the maximum allowed VAL_Message_Interval, each
                 *         containing a payload and indicating
                 *         DP# = VAL_DP
                 *         PTx = acceptable PTx value,
                 *     transmits frames on the SCH4 with
                 *         Toff = VAL_Toff
                 *     and drops the remaining frames
                 *     sends on the PCO_IN IN_Status ASPs for the transmitted frames indicating
                 *         channel = SCH4,
                 *         successful transmission
                 *     and sends on the PCO_IN IN_Status ASPs for the dropped frames indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_10(ChannelState p_sch3State, ProfileTimeAspect p_aspect) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing :=
                    "*** " & testcasename() & ": "
                    & "Testing DP" & int2str(p_aspect.profile)
                    & ", Message Interval " & fx_float2str(p_aspect.messageInterval) & "Hz"
                    & ", Toff " & fx_float2str(p_aspect.tOff) & "s"
                    & ", SCH3 state " & f_channelState2str(p_sch3State)
                    & ". ***";
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State, restrictive));
                    
                    // Start test components
                    // tOff*0.9 to sent with a rate higher than the maximum allowd VAL_Message_Interval
                    vc_itsInDcc.start(f_iN_SomeRequestedFramesSent(p_aspect.tOff*0.9, PIXIT_ACCEPTABLE_POWER_SCH4_ACTIVE, p_aspect.profile, sCH4));
                    vc_itsRrxDcc.start(f_rRX_ExpectedFramesSent(p_aspect.tOff, PIXIT_ACCEPTABLE_POWER_SCH4_ACTIVE, sCH4));
                    
                    // Synchronize both PTCs on preamble synchronization point
                    f_serverSyncClients(2, c_prDone);
                    
                    if (f_checkExpectedFrames() == e_success) {
                        setverdict(pass, v_testing);
                    }
                    else {
                        setverdict(fail, v_testing);
                    }
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }// end TC_G5B_SCH4_10
                
                /**
                 * @desc Verify that the multiple transceiver IUT drops frames with priority values above DP24 on the SCH4 in state restrictive.
                 * <pre>
                 * PICS Selection: A.2/2, A3/2, A.4/5
                 * Initial conditions:
                 *     CCH = Status irrelevant
                 *     SCH3 = VAL_State_SCH3
                 *     SCH4 = Restrictive
                 * Expected behaviour:
                 * Ensure that the IUT, with SCH4 in the restrictive state,
                 *     on receipt of an IN_Request ASP,
                 *         containing a payload and indicating
                 *         DP# in the range between 25 and 32,
                 *     drops the frame and does not transmit it,
                 *     sends on the PCO_IN an IN_Status ASP indicating
                 *         unsuccessful transmission.
                 * </pre>
                 * @see ETSI TS 102 724 clause 5.5.3, table 5
                 */
                testcase TC_G5B_SCH4_11(ChannelState p_sch3State) runs on ItsDccMts system ItsDccSystem {
                    
                    // Local variables
                    var charstring v_testing := 
                        "*** " & testcasename() & ": "
                        & "Testing SCH3 state " & f_channelState2str(p_sch3State)
                        & ". ***";
                    var float v_tOff := 0.500;
                    var integer v_dpx := float2int(int2float(32 - 25 +1)*rnd()) + 25; //random DP# in the range between 25 and 32
                    
                    // Create, connect, map test components
                    f_cfUp(vc_utComp, vc_itsInDcc, vc_itsRrxDcc, m_utRadioEvent(-, -, -, p_sch3State, restrictive));
                    
                    // Start test components
                    log(v_testing);
                    vc_itsInDcc.start(f_iN_AllRequestedFramesDropped(v_tOff, PIXIT_ACCEPTABLE_POWER_SCH4_RESTRICTIVE, v_dpx));
                    vc_itsRrxDcc.start(f_rRX_NoFramesSent(v_tOff));
                    
                    // Synchronize both PTCs on 2 synchronization points
                    f_serverSyncNClientsAndStop(2, {c_prDone, c_tbDone});
                    
                    // Disconnect, unmap test components
                    f_cfDown(vc_utComp, vc_itsInDcc, vc_itsRrxDcc);
                }// end TC_G5B_SCH4_11
                
            } // end group SCH4_restrictive_channel_state
            
        } // end group SCH4_related
        
    } // end group MultipleTransceiverITSStation_G5B
    
} // end ItsDcc_TestCases
