ItsSecurity_TestCases.ttcn

            
            /**
             * @desc  Check that the IUT accepts a message when the signing certificate of the message contains the identified region validity restriction with the identified region which is fully covered by the identified region of the validity restriction of its issuing certificate
             * <pre>
             * Pics Selection: PICS_GN_SECURITY AND PICS_USE_IDENTIFIED_REGION
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is inside the time validity period of CERT_TS_09_06_BV_AT
             *     and the IUT current location is inside the ID_REGION_AT
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           and containing certificate (CERT_TS_09_06_BV_AT)
             *             containing validity_restrictions['region']
             *               containing region_type
             *                 indicating 'id'
             *               and containing id_region
             *                 containing region_dictionary
             *                   indicating 'un_stats'
             *                 and containing region_identifier
             *                   indicating ID_REGION_AT
             *                 and containing local_region
             *                   indicating 0
             *             and containing signer_info.digest
             *               referencing to a CERT_TS_09_06_BV_AA
             *                 containing validity_restrictions['region']
             *                   containing region_type
             *                     indicating 'id'
             *                   and containing id_region
             *                     containing region_dictionary
             *                       indicating 'un_stats'
             *                     and containing region_identifier
             *                       indicating ID_REGION_AA_UNSTATS
             *                         which includes ID_REGION_AT
             *                     and containing local_region
             *                       indicating 0
             *     then
             *       the IUT accepts the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_09_06_BV
             * @reference    ETSI TS 103 097 [1], clauses 4.2.26 and 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_09_06_BV() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY) or not(PICS_USE_IDENTIFIED_REGION)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_USE_IDENTIFIED_REGION' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert0906_BV, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": PASS: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                else {
                    log("*** " & testcasename() & ": FAIL: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_09_06_BV
            
            /**
             * @desc  Check that the IUT discards a message when the signing certificate of this message does not contain the region validity restriction but its issuing certificate contains the identified region validity restriction
             * <pre>
             * Pics Selection: PICS_GN_SECURITY AND PICS_USE_IDENTIFIED_REGION
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is inside the time validity period of CERT_TS_09_07_BO_AT
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           and containing certificate (CERT_TS_09_07_BO_AT)
             *             not containing validity_restrictions['region']
             *             and containing signer_info.digest
             *               referencing to the certificate CERT_TS_E_AA
             *                 containing validity_restrictions['region']
             *                   containing region_type
             *                     indicating 'id'
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_09_07_BO
             * @reference    ETSI TS 103 097 [1], clauses 4.2.26 and 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_09_07_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY) or not(PICS_USE_IDENTIFIED_REGION)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_USE_IDENTIFIED_REGION' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert0907_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_09_07_BO
            
            /**
             * @desc  Check that the IUT discards a message when the signing certificate and its issuing certificate are both containing the identified region validity restrictions with the same region id but different local regions
             * <pre>
             * Pics Selection: PICS_GN_SECURITY AND PICS_USE_IDENTIFIED_REGION
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is inside the time validity period of CERT_TS_09_08_BO_AT
             *     and the IUT current location is inside the ID_REGION_AA, local region 1
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           and containing certificate (CERT_TS_09_08_BO_AT)
             *             containing validity_restrictions['region']
             *               containing region_type
             *                 indicating 'id'
             *               and containing id_region
             *                 containing region_dictionary
             *                   indicating 'iso_3166_1'
             *                 containing region_identifier
             *                   indicating ID_REGION_AA
             *                 containing local_region
             *                   indicating ID_LOCAL_REGION_1
             *             containing signer_info.digest
             *               referencing to a CERT_TS_09_08_BO_AA
             *                 containing validity_restrictions['region']
             *                   containing region_type
             *                     indicating 'id'
             *                   containing id_region
             *                     containing region_dictionary
             *                       indicating 'iso_3166_1'
             *                     containing region_identifier
             *                       indicating ID_REGION_AA
             *                     containing local_region
             *                       indicating ID_LOCAL_REGION_2
             *                         not equal to ID_LOCAL_REGION_1
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_09_08_BO
             * @reference    ETSI TS 103 097 [1], clauses 4.2.26 and 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_09_08_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY) or not(PICS_USE_IDENTIFIED_REGION)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_USE_IDENTIFIED_REGION' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert0908_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_09_08_BO
            
            /**
             * @desc  Check that the IUT discards a message when the identified region of the validity restriction of its signing certificate is different and not fully covered by the one in the issuing certificate
             * <pre>
             * Pics Selection: PICS_GN_SECURITY AND PICS_USE_IDENTIFIED_REGION
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is inside the time validity period of CERT_TS_09_09_BO_AT
             *     and the IUT current location is inside the ID_REGION_AT
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           and containing certificate (CERT_TS_09_09_BO_AT)
             *             containing validity_restrictions['region']
             *               containing region_type
             *                 indicating 'id'
             *               and containing id_region
             *                 containing region_dictionary
             *                   indicating 'iso_3166_1'
             *                 and containing region_identifier
             *                   indicating ID_REGION_AT
             *                 and containing local_region
             *                   indicating 0
             *             containing signer_info.digest
             *               referencing to a CERT_TS_09_09_BO_AA
             *                 containing validity_restrictions['region']
             *                   containing region_type
             *                     indicating 'id'
             *                   and containing id_region
             *                     containing region_dictionary
             *                       indicating 'iso_3166_1'
             *                     and containing region_identifier
             *                       indicating ID_REGION_AA_OTHER
             *                         other than ID_REGION_AT
             *                     and containing local_region
             *                       indicating 0
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_09_09_BO
             * @reference    ETSI TS 103 097 [1], clauses 4.2.26 and 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_09_09_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY) or not(PICS_USE_IDENTIFIED_REGION)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_USE_IDENTIFIED_REGION' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert0909_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_09_09_BO
            
            /**
             * @desc  Check that the IUT discards a message when the identified region validity restriction of its signing certificate contains unknown area code
             * <pre>
             * Pics Selection: PICS_GN_SECURITY AND PICS_USE_IDENTIFIED_REGION
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is inside the time validity period of CERT_TS_09_10_BO_AT
             *     and the IUT current location is inside the ID_REGION_AT
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           and containing certificate (CERT_TS_09_10_BO_AT)
             *             containing validity_restrictions['region']
             *               containing region_type
             *                 indicating 'id'
             *               and containing id_region
             *                 containing region_dictionary
             *                   indicating 'iso_3166_1'
             *                 and containing region_identifier
             *                   indicating ID_REGION_UNKNOWN
             *                     not existing in ISO 3166-1
             *                 and containing local_region
             *                   indicating 0
             *             and containing signer_info.digest
             *               referencing to a CERT_TS_A_AA
             *                 not containing validity_restrictions['region']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_09_10_BO
             * @reference    ETSI TS 103 097 [1], clauses 4.2.26 and 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_09_10_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY) or not(PICS_USE_IDENTIFIED_REGION)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_USE_IDENTIFIED_REGION' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert0910_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_09_10_BO
            
            /**
             * @desc  Check that the IUT discards a message when the validity restriction of its signing certificate contains the identified region of type iso-3166-1 but region code is from the UN-Stats dictionary
             * <pre>
             * Pics Selection: PICS_GN_SECURITY AND PICS_USE_IDENTIFIED_REGION
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is inside the time validity period of CERT_TS_09_11_BO_AT
             *     and the IUT current location is inside the  ID_REGION_AA_UNSTATS
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           and containing certificate (CERT_TS_09_11_BO_AT)
             *             containing validity_restrictions['region']
             *               containing region_type
             *                 indicating 'id'
             *               and containing id_region
             *                 containing region_dictionary
             *                   indicating 'iso_3166_1'
             *                 and containing region_identifier
             *                   indicating ID_REGION_AA_UNSTATS
             *                 and containing local_region
             *                   indicating 0
             *             and containing signer_info.digest
             *               referencing to a CERT_TS_A_AA
             *                 not containing validity_restrictions['region']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_09_11_BO
             * @reference    ETSI TS 103 097 [1], clauses 4.2.26 and 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_09_11_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY) or not(PICS_USE_IDENTIFIED_REGION)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY and PICS_USE_IDENTIFIED_REGION' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert0911_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_09_11_BO
            
            /**
             * @desc  Check that the IUT discards a message when its signing certificate does not contain the time validity restriction
             * <pre>
             * Pics Selection: PICS_GN_SECURITY
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           containing certificate (CERT_TS_10_01_BO_AT)
             *             not containing validity_restrictions['time_start_and_end']
             *             and not containing validity_restrictions['time_end']
             *             and not containing validity_restrictions['time_start_and_duration']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_10_01_BO
             * @reference    ETSI TS 103 097 [1], clause 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_10_01_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert1001_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_10_01_BO
            
            /**
             * @desc  Check that the IUT discards a message when the issuing certificate of the message signing certificate does not contain the time validity restriction
             * <pre>
             * Pics Selection: PICS_GN_SECURITY
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info'].signer
             *         containing type
             *           indicating 'certificate'
             *         containing certificate (CERT_TS_10_02_BO_AT)
             *           containing signer_info.digest
             *             referencing to CERT_TS_10_02_BO_AA
             *               not containing validity_restrictions['time_start_and_end']
             *               and not containing validity_restrictions['time_end']
             *               and not containing validity_restrictions['time_start_and_duration']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_10_02_BO
             * @reference    ETSI TS 103 097 [1], clause 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_10_02_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert1002_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_10_02_BO
            
            /**
             * @desc  Check that the IUT discards a message when its signing certificate contains 'time_end' validity restriction
             * <pre>
             * Pics Selection: PICS_GN_SECURITY
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is less then time_end validity restricyion of CERT_TS_10_03_BO_AT
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           containing certificate (CERT_TS_10_03_BO_AT)
             *             containing validity_restrictions['time_end']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_10_03_BO
             * @reference    ETSI TS 103 097 [1], clauses 7.4.2 & 7.4.4
             */
            testcase TC_SEC_ITSS_RCV_CERT_10_03_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert1003_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_10_03_BO
            
            /**
             * @desc  Check that the IUT discards a message when its signing certificate contains 'time_start_and_duration' validity restriction
             * <pre>
             * Pics Selection: PICS_GN_SECURITY
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is inside the time validity period of CERT_TS_10_04_BO_AT
             * Expected results:
             *   ensure that
             *     when  the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info']
             *         containing signer
             *           containing type
             *             indicating 'certificate'
             *           containing certificate (CERT_TS_10_04_BO_AT)
             *             containing validity_restrictions['time_start_and_duration']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_10_04_BO
             * @reference    ETSI TS 103 097 [1], clauses 7.4.2 & 7.4.4
             */
            testcase TC_SEC_ITSS_RCV_CERT_10_04_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert1004_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_10_04_BO
            
            /**
             * @desc  Check that the IUT discards a message when the issuing certificate of the message signing certificate contains 'time_end' validity restriction
             * <pre>
             * Pics Selection: PICS_GN_SECURITY
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is less then time_end validity restricyion of CERT_TS_10_05_BO_AT
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info'].signer
             *         containing type
             *           indicating 'certificate'
             *         containing certificate (CERT_TS_10_05_BO_AT)
             *           containing signer_info.digest
             *             referencing to CERT_TS_10_05_BO_AA
             *               containing validity_restrictions['time_end']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_10_05_BO
             * @reference    ETSI TS 103 097 [1], clauses 7.4.2 & 7.4.4
             */
            testcase TC_SEC_ITSS_RCV_CERT_10_05_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert1005_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_10_05_BO
            
            /**
             * @desc  Check that the IUT discards a message when its signing certificate contains 'time_start_and_duration' validity restriction
             * <pre>
             * Pics Selection: PICS_GN_SECURITY
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is less then time_end validity restricyion of CERT_TS_10_06_BO_AT
             * Expected results:
             *   ensure that
             *     when the IUT is receiving a SecuredMessage
             *       containing header_fields ['signer_info'].signer
             *         containing type
             *           indicating 'certificate'
             *         containing certificate (CERT_TS_10_06_BO_AT)
             *           containing signer_info.digest
             *             referencing to CERT_TS_10_06_BO_AA
             *               containing validity_restrictions['time_start_and_duration']
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_10_06_BO
             * @reference    ETSI TS 103 097 [1], clauses 7.4.2 & 7.4.4
             */
            testcase TC_SEC_ITSS_RCV_CERT_10_06_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert1006_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_10_06_BO
            
            /**
             * @desc  Check that the IUT discards a message when the validity period of the signing certificate ends after the validity period of its issuing certificate
             * <pre>
             * Pics Selection: PICS_GN_SECURITY
             * Config Id: CF01
             * Initial conditions:
             *   with
             *     the IUT being in the 'authorized' state
             *     and the IUT current time is greater than START_VALIDITY_AA and less than END_VALIDITY_AA
             * Expected results:
             *   ensure that
             *     when
             *       the IUT is receiving a SecuredMessage
             *         containing header_fields ['signer_info'].signer.certificate (CERT_TS_11_01_BO_AT)
             *           containing signer_info.digest
             *             referencing to CERT_TS_A_AA
             *               containing validity_restrictions['time_start_and_end']
             *                 containing start_validity
             *                   indicating START_VALIDITY_AA
             *                 containing end_validity
             *                   indicating END_VALIDITY_AA
             *           containing validity_restrictions['time_start_and_end']
             *             containing start_validity
             *               indicating START_VALIDITY_AA
             *             containing end_validity
             *               indicating END_VALIDITY_AA + 1d
             *     then
             *       the IUT discards the message
             * </pre>
             * @see          ETSI TS 103 096-2 v1.4.1 TP_SEC_ITSS_RCV_CERT_11_01_BO
             * @reference    ETSI TS 103 097 [1], clause 7.4.1
             */
            testcase TC_SEC_ITSS_RCV_CERT_11_01_BO() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                var GnRawPayload v_sentRawPayload;
                
                // Test adapter configuration
                if (not(PICS_GN_SECURITY)) {
                    log("*** " & testcasename() & ":ERROR: 'PICS_GN_SECURITY' required for executing the TC ***");
                    stop;
                }
                
                // Test component configuration
                f_cf01Up();
                
                // Test adapter configuration
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredCam(cc_taCert1101_BO, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                v_sentRawPayload := f_adaptPayloadForUtInd_m(v_securedGnPdu.gnPacket.packet.payload);
                for (i := 0; i < lengthof(vc_utInds) and not match(vc_utInds[i].rawPayload, v_sentRawPayload); i := i + 1) {
                    // Empty on purpose 
                }
                if (i < lengthof(vc_utInds)) {
                    log("*** " & testcasename() & ": FAIL: GN was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                else {
                    log("*** " & testcasename() & ": PASS: GN was not transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_CERT_11_01_BO
            
            /**