ItsAtsp_TestCases.ttcn

/**
 *  @author   ETSI / STF455
 *  @version  $URL$
 *            $Id$
 *  @desc     Testcases for Access Technology Support Protocols (ISO 21218) (TP version: 1.1.2 - v06)
 *
 */
 module ItsAtsp_TestCases {

    // Libcommon
    import from LibItsCalm_Interface all;
    import from LibCommon_Sync all;
    import from LibCommon_BasicTypesAndValues {
            type UInt8
            };

    // LibIts
    import from LibItsAtsp_Pics all;
    import from LibItsAtsp_Pixits all;
    import from LibItsAtsp_Templates all;
    import from LibItsAtsp_TypesAndValues all;
    import from LibItsAtsp_Functions all;
    import from LibItsAtsp_Pixits all;
    
    import from LibItsCalm_TestSystem {
        type ItsCalmSystem 
    };

    import from LibItsCalm_Interface {
        type ItsCalm
       };

    import from LibItsMgt_Functions {
        function f_getNextCommandRef
    };

    import from LibItsMgt_TypesAndValues {
        type IParamNoList, IParamList
    }; 
    
    // ASN.1 modules    
    import from CALMllsap language "ASN.1:1997" {
        type 
            Link_ID, MedType, CIstatus, VirtualCIs,
            IN_UNITDATA_request,
            I_Param, DataRate, Errors,
            UserPriority,
            INsapPrimitivesUp,
            RemoteCIID
    };
    import from CALMmsap language "ASN.1:1997" {
        type 
            MI_Command_request, MI_Command_confirm
    };
    
    
    // State event transitions
    group stateEventTransitions {
            
        group validBehavior {

                /**
                 * @desc    TP: IUT with CI supporting 48-bit MAC addresses registers correctly at the management entity
                 * @author  STF 455
                 * @config  
                 * 
                 * <pre>
                 * PICS selection: PICS_DYNREG AND PICS_MAC48
                 * Initial conditions: 
                 *  with {
                 *       the IUT being in the CI state "not-existent"
                 *       }
                 * 
                 * Expected behaviour:
                 *  ensure that {
                 *     when {
                 *          the IUT starts operation
                 *          }
                 *     then {
                 *          the IUT registers properly at the ITS-S management
                 *          }
                 *     }
                 *     
                 * Final conditions:
                 * ensure that {
                 *     when {
                 *          the IUT presented the state "registered" to the ITS-S management
                 *          }
                 *     then {
                 *          the IUT has a LocalCIID representing the 48 bit MAC address of the IUT
                 *          }
                 *     }
                 * </pre>
                 * 
                 * @version 2013-05-07.0
                 * @since   2013-05-07.0
                 * @status  empty test case
                 * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/01
                 * @remark  to be created
                 */
            testcase TC_ATSP_SE_BV_01() runs on ItsCalm system ItsCalmSystem {
                // Local variables
                
                // Test control
                if (not(PICS_DYNREG and PICS_MAC48)) {
                    log("*** TC_ATSP_SE_BV_01: ERROR: 'PICS_DYNREG' and 'PICS_MAC48' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                // Clause 'Initial conditions'
                // Request operator to switch on the SUT or to activate the IUT
                action("Switch on SUT or activate IUT");
                
                // Test Body
                // Clause 'when'
                log("*** TC_ATSP_SE_BV_01: INFO: Waiting for power-on of IUT ***");
                
                // Clause 'then'
                
                // Wait for MI-Request.request "RegReq"
                f_cnAwaitAndConfirmMI_RequestCI(mw_miRegRequest(f_get_CI_LinkID(), ?, m_regRequest(PX_CI_MED_TYPE)), true);
                
                // Reply MI-Command.request "RegCmd"
                f_cnSendMICOMMAND_RequestCheckSuccessCI(m_miRegistrationCommandRequest(
                                                            f_get_CI_LinkID(), 
                                                            f_getNextCommandRef(), 
                                                            m_regCommand(PX_ITS_SCU_ID, PX_CI_MED_TYPE)), true);
                
                // Clause 'when'
                // the IUT registers properly at the ITS-S management
                // the IUT presented the state "registered" to the ITS-S management
                f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusRegistered)), true);
            
                //Clause 'then'
                // the IUT has a LocalCIID representing the 48 bit MAC address of the IUT
                // Try to address the VCI using the expected Link-ID. Return value is not used.
                f_cnGetCiStatusParameterValueCI(f_get_CI_LinkID());
                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                log("*** TC_ATSP_SE_BV_01: INFO: test body done ***");
                
                // Postamble
                f_poDefault();
                f_cf01Down();
                log("*** TC_ATSP_SE_BV_01: INFO: Postamble: done ***");                
            } // End of testcase TC_ATSP_SE_BV_01
            
            /**
             * @desc    TP: IUT with CI not supporting 48-bit MAC addresses registers correctly at the management entity
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_DYNREG AND NOT PICS_MAC48
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state "not-existent"
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT starts operation
             *          }
             *     then {
             *          the IUT registers properly at the ITS-S management
             *          }
             *     }
             *     
             * Final conditions:
             * ensure that {
             *     when {
             *          the IUT presented the state "registered" to the ITS-S management
             *          }
             *     then {
             *          the IUT has a LocalCIID created from ITS-SCU-ID and MedID
             *          }
             *     }
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/02
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_02() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    
                    // Test control
                    if (not(PICS_DYNREG and not PICS_MAC48)) {
                        log("*** TC_ATSP_SE_BV_02: ERROR: 'PICS_DYNREG' and NOT 'PICS_MAC48' required for executing the TC ***");
                        stop;
                    }
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    
                    // Test Body
                    // Clause 'then'
                    
                    // Wait for MI-Request.request "RegReq"
                    f_cnAwaitAndConfirmMI_RequestCI(mw_miRegRequest(f_get_CI_LinkID(), ?, m_regRequest(PX_CI_MED_TYPE)), true);
                    
                    // Reply MI-Command.request "RegCmd"
                    f_cnSendMICOMMAND_RequestCheckSuccessCI(m_miRegistrationCommandRequest(
                                                            f_get_CI_LinkID(), 
                                                            f_getNextCommandRef(), 
                                                            m_regCommand(PX_ITS_SCU_ID, PX_CI_MED_TYPE)), false);
                    
                    //Clause 'when'
                    //the IUT registers properly at the ITS-S management
                    //        the IUT presented the state "registered" to the ITS-S management
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusRegistered)), true);
                
                    //Clause 'then'
                    //        the IUT has a LocalCIID created from ITS-SCU-ID and MedID
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_02: INFO: test body done ***");
                        
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_02: INFO: Postamble: done ***");
                    
                } // End of testcase TC_ATSP_SE_BV_02
            
            /**
             * @desc    TP: IUT repeats registration as long as management entity does not confirm it
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_DYNREG
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state "not-existent"
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT starts operation
             *          }
             *     then {
             *          the IUT repeats continuously the registration procedure as long as the ITS-S management does not confirm with MI-COMMAND "RegCmd"
             *          }
             *     }
             *     
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/03
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_03() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    var boolean v_discard;
                    var integer v_messageCounter;
                    
                    // Test control
                    if (not(PICS_DYNREG)) {
                        log("*** TC_ATSP_SE_BV_03: ERROR: 'PICS_DYNREG' required for executing the TC ***");
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    // Test Body
                    // Clause 'when'
                    log("*** TC_ATSP_SE_BV_03: INFO: Waiting for power-on of IUT ***");
                    
                    // Clause 'then'
                    for(v_messageCounter := 0; v_messageCounter < 5; v_messageCounter := v_messageCounter + 1) {
                        // Wait for MI-Request.request "RegReq"
                        f_cnAwaitAndConfirmMI_RequestCI(mw_miRegRequest(f_get_CI_LinkID(), ?, m_regRequest(PX_CI_MED_TYPE)), true);
                    }
                    
                    // Reply MI-Command.request "RegCmd"
                    f_cnSendMICOMMAND_RequestCheckSuccessCI(m_miRegistrationCommandRequest(
                                                            f_get_CI_LinkID(), 
                                                            f_getNextCommandRef(), 
                                                            m_regCommand(PX_ITS_SCU_ID, PX_CI_MED_TYPE)), false);
                                
                    // Check for reception of Status notification (I-Parameter 12 "CIstatus" set to "registered". 
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusRegistered)), true);
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_03: INFO: test body done ***");
                    
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_03: INFO: Postamble: done ***");
                    
                } // End of testcase TC_ATSP_SE_BV_03                

            /**
             * @desc    TP: IUT with CI class "CIC-l2" automatically creates a UC-VCI and reaches the CI state "active"
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_CIC_l2
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state "not-existent"
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT has finished the registration procedure
             *          }
             *     then {
             *          the IUT creates a UC-VCI
             *          }
             *     }
             *     
             * Final conditions:
             * ensure that {
             *     when {
             *          the IUT created a UC-VCI
             *          }
             *     then {
             *          the IUT is in the state "active"
             *          }
             *     }
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/04
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_04() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    var integer v_messageCounter;
                    
                    // Test control
                    if (not(PICS_CIC_l2)) {
                        log("*** TC_ATSP_SE_BV_04: ERROR: 'PICS_CIC_l2' required for executing the TC ***");
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    // Test Body
                    // Clause 'when'
                    // the IUT has finished the registration procedure
                    f_cnAwaitRegistrationCI(f_get_CI_LinkID(), PX_CI_MED_TYPE, true);
                    
                    // Clause 'then'
                    //the IUT creates a UC-VCI(applying MAC unicast communications)
                    
                    //TODO: Cecking for a UC-VCI
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_UC, f_get_CI_Local_CIID())), true);
                    
                    // Clause 'then'
                    // the IUT is in the state "active"
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusActive)), true);
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_04: INFO: test body done ***");
                    
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_04: INFO: Postamble: done ***");
                    
                } // End of testcase TC_ATSP_SE_BV_04

            /**
             * @desc    TP: IUT with CI class "CIC-l3" automatically creates a BC-VCI and reaches the CI state "active"
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_CIC_l3
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state "not-existent"
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT has finished the registration procedure
             *          }
             *     then {
             *          the IUT creates a BC-VCI
             *          }
             *     }
             *     
             * Final conditions:
             * ensure that {
             *     when {
             *          the IUT created a BC-VCI
             *          }
             *     then {
             *          the IUT is in the state "active"
             *          }
             *     }
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/05
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_05() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    var integer v_messageCounter;
                    
                    // Test control
                    if (not(PICS_CIC_l3)) {
                        log("*** TC_ATSP_SE_BV_05: ERROR: 'PICS_CIC_l3' required for executing the TC ***");
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    // Test Body
                    // Clause 'when'
                    f_cnAwaitRegistrationCI(f_get_CI_LinkID(), PX_CI_MED_TYPE, true);
                    
                    // Clause 'then'
                    //the IUT creates a BC-VCI(applying MAC broadcast communications)
                    //TODO: checking for BC-VCI
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_BC, f_get_CI_Local_CIID())), true);
                    
                    // Clause 'then'
                    // the IUT is in the state "active"
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusActive)), true);
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_05: INFO: test body done ***");
        
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_05: INFO: Postamble: done ***");
                } // End of testcase TC_ATSP_SE_BV_05

            /**
             * @desc    TP: IUT with CI class "CIC-l4" automatically creates a RX-VCI and reaches the CI state "active"
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_CIC_l4
             * Initial conditions: 
             *  with {
             *       he IUT being in the CI state "registered"
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT has finished the registration procedure
             *          }
             *     then {
             *          the IUT creates a RX-VCI
             *          }
             *     }
             *     
             * Final conditions:
             * ensure that {
             *     when {
             *          the IUT created a BC-VCI
             *          }
             *     then {
             *          the IUT is in the state "active"
             *          }
             *     }
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/06
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_06() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    var integer v_messageCounter;
                    
                    // Test control
                    if (not(PICS_CIC_l4)) {
                        log("*** TC_ATSP_SE_BV_06: ERROR: 'PICS_CIC_l4' required for executing the TC ***");
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    // Test Body
                    // Clause 'when'
                    f_cnAwaitRegistrationCI(f_get_CI_LinkID(), PX_CI_MED_TYPE, true);
                    
                    // Clause 'then'
                    //the IUT creates a RX-VCI
                    // this is given by notification of the status "active"
                    
                    // Clause 'then'
                    // the IUT is in the state "active"
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusActive)), true);
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_06: INFO: test body done ***");
        
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_06: INFO: Postamble: done ***");
                    
                } // End of testcase TC_ATSP_SE_BV_06

            /**
             * @desc    TP: IUT with CI class "CIC-l1"or "CIC-il1" automatically creates a UC-VCI and a BC-VCI and reaches the CI state "active"
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_CIC_l1 OR PICS_CIC_il1
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state "registered", and MAC multicast groups are not known to the IUT
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT has finished the registration procedure
             *          }
             *     then {
             *          the IUT creates a UC-VCI and a BC-VCI
             *          }
             *     }
             *     
             * Final conditions:
             * ensure that {
             *     when {
             *          the IUT created a UC-VCI and a BC-VCI
             *          }
             *     then {
             *          the IUT is in the state "active"
             *          }
             *     }
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/07
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_07() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    var CfAtspEventInd v_result;
                    var template CfAtspEventInd v_cf_UC_VCI_Event;
                    var boolean v_UC_VCI_created;
                    var template CfAtspEventInd v_cf_BC_VCI_Event;
                    var boolean v_BC_VCI_created;
                    var boolean v_discard := true;
                    
                    // Test control
                    if (not(PICS_CIC_l1 or PICS_CIC_il1)) {
                        log("*** TC_ATSP_SE_BV_07: ERROR: 'PICS_CIC_l1' OR 'PICS_CIC_il1' required for executing the TC ***");
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    // Test Body
                    // Clause 'when'
                    f_cnAwaitRegistrationCI(f_get_CI_LinkID(), PX_CI_MED_TYPE, true);
                    
                    // Clause 'then'
                    //the IUT creates a BC-VCI(applying MAC broadcast communications)
                    v_UC_VCI_created := false;
                    v_BC_VCI_created := false;
                    
                    //TODO: UC-VCI and a BC-VCI correct template values, how to distinguish between UC and BC?
                    v_cf_UC_VCI_Event := mw_cfAtspRequestRequest(
                                        mw_miEventsRequest(f_get_CI_LinkID(), ?, mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_UC, f_get_CI_Local_CIID()))));
                    v_cf_BC_VCI_Event := mw_cfAtspRequestRequest(
                                        mw_miEventsRequest(f_get_CI_LinkID(), ?, mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_BC, f_get_CI_Local_CIID()))));
                    
                    log("*** TC_ATSP_SE_BV_07: INFO: Expected MI-Request-request: ", v_cf_UC_VCI_Event, " ***");
                    log("*** TC_ATSP_SE_BV_07: INFO: Expected MI-Request-request: ", v_cf_BC_VCI_Event, " ***");
                    tc_wait.start;
                    alt {
                        [not v_UC_VCI_created] cfPort.receive(v_cf_UC_VCI_Event) -> value v_result {
                            v_UC_VCI_created := true;
                            log("*** TC_ATSP_SE_BV_07: INFO: Expected UC-VCI creation event received ***");
                            f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                            if(not v_BC_VCI_created)
                            {
                                tc_wait.start;
                                repeat;
                            }
                            tc_wait.stop;
                        }
                        [not v_BC_VCI_created] cfPort.receive(v_cf_BC_VCI_Event) -> value v_result {
                            v_BC_VCI_created := true;
                            log("*** TC_ATSP_SE_BV_07: INFO: Expected BC-VCI creation event received ***");
                            f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                            if(not v_UC_VCI_created)
                            {
                                tc_wait.start;
                                repeat;
                            }
                            tc_wait.stop;
                        }
                        [] cfPort.receive(CfAtspEventInd : ?) -> value v_result { 
                            if (v_discard == false) { 
                                tc_wait.stop;
                                log("*** TC_ATSP_SE_BV_07: ERROR: An unexpected MI-REQUEST was received ***", v_result);
                                f_selfOrClientSyncAndVerdict("error", e_timeout); // to be checked
                            } else { 
                                log("*** TC_ATSP_SE_BV_07: INFO: An unexpected MI-REQUEST was received, repeating check ***");
                                f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                                repeat;
                            } 
                        }
                        [] tc_wait.timeout {
                            log("*** TC_ATSP_SE_BV_07: ERROR: Timeout while waiting for event check result ***");
                            f_selfOrClientSyncAndVerdict("error", e_timeout); // to be checked
                        }
                    } // End of 'alt' statement
                    
                    // Clause 'then'
                    // the IUT is in the state "active"
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusActive)), true);
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_07: INFO: test body done ***");
        
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_07: INFO: Postamble: done ***");
                    
                } // End of testcase TC_ATSP_SE_BV_07

            /**
             * @desc    TP: IUT with CI class "CIC-l3" automatically creates a BC-VCI and known MC-VCIs and reaches the CI state "active"
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_CIC_l3 AND PICS_MCVCI
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state "registered", and at least one MAC multicast group is known to the IUT
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT has finished the registration procedure
             *          }
             *     then {
             *          the IUT creates a BC-VCI and a MC-VCI for each known MAC multicast group
             *          }
             *     }
             *     
             * Final conditions:
             * ensure that {
             *     when {
             *          the IUT created a BC-VCI and the MC-VCI(s)
             *          }
             *     then {
             *          the IUT is in the state "active"
             *          }
             *     }
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/08
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_08() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    var integer v_messageCounter;
                    var CfAtspEventInd v_result;
                    var template CfAtspEventInd v_cf_BC_VCI_Event;
                    var boolean v_BC_VCI_created;
                    var template CfAtspEventInd v_cf_MC_VCI_Event;
                    var boolean v_MC_VCI_created;
                    var boolean v_discard := true;
                    
                    // Test control
                    if (not(PICS_CIC_l3 and PICS_MCVCI)) {
                        log("*** TC_ATSP_SE_BV_08: ERROR: 'PICS_CIC_l3' OR 'PICS_MCVCI' required for executing the TC ***");
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    // Test Body
                    // Clause 'when'
                    f_cnAwaitRegistrationCI(f_get_CI_LinkID(), PX_CI_MED_TYPE, true);
                    
                    // Clause 'then'
                    //the IUT creates a BC-VCI(applying MAC broadcast communications)
                    v_BC_VCI_created := false;
                    v_MC_VCI_created := false;
                    v_cf_BC_VCI_Event := mw_cfAtspRequestRequest(
                                        mw_miEventsRequest(mw_miLinkIndAny, ?, mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_BC, f_get_CI_Local_CIID()))));
                    v_cf_MC_VCI_Event := mw_cfAtspRequestRequest(
                                        mw_miEventsRequest(mw_miLinkIndAny, ?, mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_MC, f_get_CI_Local_CIID()))));
                    
                    log("*** TC_ATSP_SE_BV_08: INFO: Expected MI-Request-request: ", v_cf_BC_VCI_Event, " ***");
                    log("*** TC_ATSP_SE_BV_08: INFO: Expected MI-Request-request: ", v_cf_MC_VCI_Event, " ***");
                    tc_wait.start;
                    alt {
                        [not v_BC_VCI_created] cfPort.receive(v_cf_BC_VCI_Event) -> value v_result {
                            v_BC_VCI_created := true;
                            log("*** TC_ATSP_SE_BV_08: INFO: Expected BC-VCI creation event received ***");
                            f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                            if(not v_MC_VCI_created)
                            {
                                tc_wait.start;
                                repeat;
                            }
                            tc_wait.stop;
                        }
                        [not v_MC_VCI_created] cfPort.receive(v_cf_MC_VCI_Event) -> value v_result{
                            v_MC_VCI_created := true;
                            log("*** TC_ATSP_SE_BV_08: INFO: Expected MC-VCI creation event received ***");
                            f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                            if(not v_BC_VCI_created)
                            {
                                tc_wait.start;
                                repeat;
                            }
                            tc_wait.stop;
                        }
                        [] cfPort.receive(mw_miEventMI_RequestRequest_any) -> value v_result { 
                            if (v_discard == false) { 
                                tc_wait.stop;
                                log("*** TC_ATSP_SE_BV_08: ERROR: An unexpected MI-REQUEST was received ***", v_result);
                                f_selfOrClientSyncAndVerdict("error", e_timeout); // to be checked
                            } else { 
                                log("*** TC_ATSP_SE_BV_08: INFO: An unexpected MI-REQUEST was received, repeating check ***");
                                f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                                repeat;
                            } 
                        }
                        [] tc_wait.timeout {
                            log("*** TC_ATSP_SE_BV_08: ERROR: Timeout while waiting for event check result ***");
                            f_selfOrClientSyncAndVerdict("error", e_timeout); // to be checked
                        }
                    } // End of 'alt' statement
                    
                    // Clause 'then'
                    // the IUT is in the state "active"
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusActive)), true);
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_08: INFO: test body done ***");
        
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_08: INFO: Postamble: done ***");
                    
                } // End of testcase TC_ATSP_SE_BV_08

            /**
             * @desc    TP: IUT with CI class "CIC-l1" or "CIC-il1" automatically creates a UC-VCI and a BC-VCI and known MC-VCIs and reaches the CI state "active"
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: (PICS_CIC_l1 OR PICS_CIC_il1) AND PICS_MCVCI
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state "registered", and at least one MAC multicast group is known to the IUT
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT has finished the registration procedure
             *          }
             *     then {
             *          the IUT creates a UC-VCI and a BC-VCI and the MC-VCI(s)
             *          }
             *     }
             *     
             * Final conditions:
             * ensure that {
             *     when {
             *          the IUT created a UC-VCI and a BC-VCI and the MC-VCIs
             *          }
             *     then {
             *          the IUT is in the state "active"
             *          }
             *     }
             * </pre>
             * 
             * @version 2013-05-07.0
             * @since   2013-05-07.0
             * @status  empty test case
             * @reference     ETSI TS 102 760-2 v1.1.2_STF455_v06 SE/BV/09
             * @remark  to be created
             */
                testcase TC_ATSP_SE_BV_09() runs on ItsCalm system ItsCalmSystem {
                    // Local variables
                    var boolean v_discard;
                    var CfAtspEventInd v_result;
                    var template CfAtspEventInd v_cf_UC_VCI_Event;
                    var boolean v_UC_VCI_created;
                    var template CfAtspEventInd v_cf_BC_VCI_Event;
                    var boolean v_BC_VCI_created;
                    var template CfAtspEventInd v_cf_MC_VCI_Event;
                    var boolean v_MC_VCI_created;
                    
                    // Test control
                    if (not((PICS_CIC_l1 or PICS_CIC_il1)and PICS_MCVCI)) {
                        log("*** TC_ATSP_SE_BV_09: ERROR: ('PICS_CIC_l1' OR 'PICS_CIC_il1') AND 'PICS_MCVCI' required for executing the TC ***");
                        stop;
                    }
                    
                    // Test component configuration
                    f_cf01Up();
                    
                    // Test adapter configuration
                    
                    // Preamble
                    // Clause 'Initial conditions'
                    // Request operator to switch on the SUT or to activate the IUT
                    action("Switch on SUT or activate IUT");
                    
                    // Test Body
                    // Clause 'when'
                    f_cnAwaitRegistrationCI(f_get_CI_LinkID(), PX_CI_MED_TYPE, true);
                    
                    // Clause 'when'
                    v_UC_VCI_created := false;
                    v_BC_VCI_created := false;
                    v_MC_VCI_created := false;
                    
                    //TODO: correct template values for UC-VCI, BC-VCI and MC-VCI
                    v_cf_UC_VCI_Event := mw_cfAtspRequestRequest(
                                        mw_miEventsRequest(mw_miLinkIndAny, ?, mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_UC, f_get_CI_Local_CIID()))));
                    v_cf_BC_VCI_Event := mw_cfAtspRequestRequest(
                                        mw_miEventsRequest(mw_miLinkIndAny, ?, mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_BC, f_get_CI_Local_CIID()))));
                    v_cf_MC_VCI_Event := mw_cfAtspRequestRequest(
                                        mw_miEventsRequest(mw_miLinkIndAny, ?, mw_miEvent21218_3(mw_miVCICreDelRes(PX_REMOTE_CIID_MC, f_get_CI_Local_CIID()))));
                    
                    log("*** TC_ATSP_SE_BV_09: INFO: Expected MI-Request-request: ", v_cf_UC_VCI_Event, " ***");
                    log("*** TC_ATSP_SE_BV_09: INFO: Expected MI-Request-request: ", v_cf_BC_VCI_Event, " ***");
                    log("*** TC_ATSP_SE_BV_09: INFO: Expected MI-Request-request: ", v_cf_MC_VCI_Event, " ***");
                    tc_wait.start;
                    alt {
                        [not v_UC_VCI_created] cfPort.receive(v_cf_UC_VCI_Event) -> value v_result {
                            v_UC_VCI_created := true;
                            log("*** TC_ATSP_SE_BV_09: INFO: Expected UC-VCI creation event received ***");
                            f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                            if(not v_BC_VCI_created or not v_MC_VCI_created)
                            {
                                tc_wait.start;
                                repeat;
                            }
                            tc_wait.stop;
                        }
                        [not v_BC_VCI_created] cfPort.receive(v_cf_BC_VCI_Event) -> value v_result{
                            v_BC_VCI_created := true;
                            log("*** TC_ATSP_SE_BV_09: INFO: Expected BC-VCI creation event received ***");
                            f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                            if(not v_UC_VCI_created or not v_MC_VCI_created)
                            {
                                tc_wait.start;
                                repeat;
                            }
                            tc_wait.stop;
                        }
                        [not v_MC_VCI_created] cfPort.receive(v_cf_MC_VCI_Event) -> value v_result{
                            v_MC_VCI_created := true;
                            log("*** TC_ATSP_SE_BV_09: INFO: Expected MC-VCI creation event received ***");
                            f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                            if(not v_UC_VCI_created or not v_BC_VCI_created)
                            {
                                tc_wait.start;
                                repeat;
                            }
                            tc_wait.stop;
                        }
                        [] cfPort.receive(mw_miEventMI_RequestRequest_any) -> value v_result { 
                            if (v_discard == false) { 
                                tc_wait.stop;
                                log("*** TC_ATSP_SE_BV_09: ERROR: An unexpected MI-REQUEST was received ***", v_result);
                                f_selfOrClientSyncAndVerdict("error", e_timeout); // to be checked
                            } else { 
                                log("*** TC_ATSP_SE_BV_09: INFO: An unexpected MI-REQUEST was received, repeating check ***");
                                f_cnConfirmMI_RequestCI(m_cfAtspRequestConfirm(v_result.miRequestRequest, c_ciErrStatusSuccess));
                                repeat;
                            } 
                        }
                        [] tc_wait.timeout {
                            log("*** TC_ATSP_SE_BV_09: ERROR: Timeout while waiting for event check result ***");
                            f_selfOrClientSyncAndVerdict("error", e_timeout); // to be checked
                        }
                    } // End of 'alt' statement
                    
                    // Clause 'then'
                    // the IUT is in the state "active"
                    f_cnAwaitEventNotificationCI(f_get_CI_LinkID(), mw_miEvent21218_5(mw_miCIStatusParam(c_ciStatusActive)), true);
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                    log("*** TC_ATSP_SE_BV_09: INFO: test body done ***");
        
                    // Postamble
                    f_poDefault();
                    f_cf01Down();
                    log("*** TC_ATSP_SE_BV_09: INFO: Postamble: done ***");
                    
                } // End of testcase TC_ATSP_SE_BV_09

            /**
             * @desc    TP: IUT deregisters correctly from the management entity
             * @author  STF 455
             * @config  
             * 
             * <pre>
             * PICS selection: PICS_DYNREG
             * Initial conditions: 
             *  with {
             *       the IUT being in the CI state different to "existent" or "not_existent"
             *       }
             * 
             * Expected behaviour:
             *  ensure that {
             *     when {
             *          the IUT receives the COMMAND "CIstateChng" with the value "deregister"
             *          }
             *     then {
             *          the IUT performs deregistration