ItsSecurity_TestCases.ttcn3

             * Config Id: CF01
             * Initial conditions:
             * with {
             *   the IUT being in the 'authorized' state
             * }
             * ensure that {
             *   when {
             *     the IUT is requested to send DENM
             *   } then {
             *     the IUT is receiving a SecuredMessage {
             *          containing header_fields['signer_info'].type
             *              indicating 'certificate'
             *          and containing  header_fields ['signer_info'].certificate (CERT_AT_B)
             *              containing validity_restrictions['region'] {
             *                  containing region{
             *                      containing region_type
             *                          indicating 'circle'
             *                      and containing circular_region
             *                          indicating REGION
             *                  }
             *              }
             *          and containing header_fields ['generation_location']
             *              containing generation_location
             *                  indicating position outside the REGION
             *          and containing header_fields['its_aid']
             *              indicating 'AID_DENM'
             *   }
             * }
             * </pre>
             * @see
             * @reference ETSI TS 103 097 V1.1.14, clause 7.2
             */
            testcase TC_SEC_ITSS_RCV_DENM_08_01a_EB() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                
                //  Test component configuration
                f_cf01Up();
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredDenm(cc_taCertB, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                if (lengthof(vc_utInds) == 0) {
                    log("*** " & testcasename() & ": PASS: DENM was dropped by the IUT ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                else {
                    log("*** " & testcasename() & ": FAIL: DENM was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_DENM_08_01a_EB
            
            /**
             * @desc    Check that IUT discards Secured DENM if the HeaderField generation_location is outside of the rectangilar validity region of the signing certificate
             * <pre>
             * Pics Selection: none
             * Config Id: CF01
             * Initial conditions:
             * with {
             *   the IUT being in the 'authorized' state
             * }
             * ensure that {
             *   when {
             *     the IUT is requested to send DENM
             *   } then {
             *     the IUT is receiving a SecuredMessage {
             *          containing header_fields['signer_info'].type
             *              indicating 'certificate'
             *          and containing  header_fields ['signer_info'].certificate (CERT_AT_C)
             *              containing validity_restrictions['region'] {
             *                  containing region{
             *                      containing region_type
             *                          indicating 'rectangle'
             *                      and containing rectangular_regions
             *                          indicating REGION
             *                  }
             *              }
             *          and containing header_fields ['generation_location']
             *              containing generation_location
             *                  indicating position outside the REGION
             *          and containing header_fields['its_aid']
             *              indicating 'AID_DENM'
             *   }
             * }
             * </pre>
             * @see
             * @reference ETSI TS 103 097 V1.1.14, clause 7.2
             */
            testcase TC_SEC_ITSS_RCV_DENM_08_01b_EB() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                
                //  Test component configuration
                f_cf01Up();
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredDenm(cc_taCertC, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                if (lengthof(vc_utInds) == 0) {
                    log("*** " & testcasename() & ": PASS: DENM was dropped by the IUT ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                else {
                    log("*** " & testcasename() & ": FAIL: DENM was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_DENM_08_01b_EB
            
            /**
             * @desc    Check that IUT discards Secured DENM if the HeaderField generation_location is outside of the polygonal validity region of the signing certificate    
             * <pre>
             * Pics Selection: none
             * Config Id: CF01
             * Initial conditions:
             * with {
             *   the IUT being in the 'authorized' state
             * }
             * ensure that {
             *   when {
             *     the IUT is requested to send DENM
             *   } then {
             *     the IUT is receiving a SecuredMessage {
             *          containing header_fields['signer_info'].type
             *              indicating 'certificate'
             *          and containing  header_fields ['signer_info'].certificate (CERT_AT_D)
             *              containing validity_restrictions['region'] {
             *                  containing region{
             *                      containing region_type
             *                          indicating 'polygon'
             *                      and containing polygonal_region
             *                          indicating REGION
             *                  }
             *              }
             *          and containing header_fields ['generation_location']
             *              containing generation_location
             *                  indicating position outside the REGION
             *          and containing header_fields['its_aid']
             *              indicating 'AID_DENM'
             *   }
             * }
             * </pre>
             * @see
             * @reference ETSI TS 103 097 V1.1.14, clause 7.2
             */
            testcase TC_SEC_ITSS_RCV_DENM_08_01c_EB() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                
                //  Test component configuration
                f_cf01Up();
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredDenm(cc_taCertD, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                if (lengthof(vc_utInds) == 0) {
                    log("*** " & testcasename() & ": PASS: DENM was dropped by the IUT ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                else {
                    log("*** " & testcasename() & ": FAIL: DENM was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_DENM_08_01c_EB
            
            /**
             * @desc    Check that IUT discards Secured DENM if the HeaderField generation_location is outside of the identified validity region of the signing certificate 
             * <pre>
             * Pics Selection: none
             * Config Id: CF01
             * Initial conditions:
             * with {
             *   the IUT being in the 'authorized' state
             * }
             * ensure that {
             *   when {
             *     the IUT is requested to send DENM
             *   } then {
             *     the IUT is receiving a SecuredMessage {
             *          containing header_fields['signer_info'].type
             *              indicating 'certificate'
             *          and containing  header_fields ['signer_info'].certificate (CERT_AT_E)
             *              containing validity_restrictions['region'] {
             *                  containing region{
             *                      containing region_type
             *                          indicating 'id_region'
             *                      and containing identified_region
             *                          indicating REGION
             *                  }
             *              }
             *          and containing header_fields ['generation_location']
             *              containing generation_location
             *                  indicating position outside the REGION
             *          and containing header_fields['its_aid']
             *              indicating 'AID_DENM'
             *   }
             * }
             * </pre>
             * @see
             * @reference ETSI TS 103 097 V1.1.14, clause 7.2
             */
            testcase TC_SEC_ITSS_RCV_DENM_08_01d_EB() runs on ItsGeoNetworking system ItsSecSystem {
                
                // Local variables
                var integer i;
                var GeoNetworkingPdu v_securedGnPdu;
                
                //  Test component configuration
                f_cf01Up();
                
                // Preamble
                f_prNeighbour();
                f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
                
                // Test Body
                v_securedGnPdu := f_sendSecuredDenm(cc_taCertE, omit, e_certificate);
                
                f_sleep(PX_TNOAC);
                if (lengthof(vc_utInds) == 0) {
                    log("*** " & testcasename() & ": PASS: DENM was dropped by the IUT ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                else {
                    log("*** " & testcasename() & ": FAIL: DENM was transmitted to upper layer ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                
                // Postamble
                f_poNeighbour();
                f_cf01Down();
            } // End of testcase TC_SEC_ITSS_RCV_DENM_08_01d_EB
            
        } // End of group g_recvDenmProfile
        
    } // End of group g_receiverbehavior
    
    group g_Certificates {
        
        /**
         * @desc    Check that AT certificate has version 2
         * <pre>
         * Pics Selection: none
         * Config Id: CF01
         * Initial conditions:
         * with {
         *   the IUT being in the 'authorized' state
         *   the IUT being requested to include certificate in the next CAM
         * }
         * Expected Behaviour:
         * ensure that {
         *    when {
         *     the IUT is requested to send a CAM
         *   } then {
         *     the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *         containing type
         *           indicating certificate
         *         containing certificate {
         *           containing version
         *             indicating '2'
         *         }
         *       }
         *   }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clause 6.1
         */
        testcase TC_SEC_SND_CERT_01_01() runs on ItsGeoNetworking system ItsSecSystem {
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Test Body
            tc_ac.start;
            alt {
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwSecPdu(
                            mdw_securedMessage(
                                superset(
                                    mw_header_field_signer_info_certificate(
                                        mw_certificate(
                ))))))) {
                    tc_ac.stop;
                    log("*** " & testcasename() & ": PASS: AT Certificate version set to " & int2char(c_certificate_version) & " ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwSecPdu(
                            mdw_securedMessage(
                                superset(
                                    mw_header_field_signer_info_certificate(
                                        ?
                )))))) {
                    tc_ac.stop;
                    log("*** " & testcasename() & ": FAIL: AT Certificate version mismatch ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                [] tc_ac.timeout {
                    log("*** " & testcasename() & ": INCONC: Expected message not received ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
                }
            } // End of 'alt' statement
            
            // Postamble
            f_poNeighbour();
            f_cf01Down();
        } // End of testcase TC_SEC_SND_CERT_01_01
        
        /**
         * @desc    Check that AA certificate has version 2
         * <pre>
         * Pics Selection: none
         * Config Id: CF01
         * Initial conditions:
         * with {
         *   the IUT being in the 'authorized' state
         *      the IUT being requested to include certificate chain in the next CAM
         * }
         * Expected Behaviour:
         * ensure that {
         *    when {
         *     the IUT is requested to send a CAM
         *   } then {
         *     the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *         containing type
         *           indicating certificate_chain
         *         containing certificates.length >1
         *         containing certificates[last-1] {
         *           containing version
         *             indicating '2'
         *         }
         *       }
         *   }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clause 6.1
         */
        testcase TC_SEC_SND_CERT_01_02() runs on ItsGeoNetworking system ItsSecSystem {
            // Local declarations
            var SecuredMessage v_recv;
            var Certificate v_cert;
            var SignerInfo v_si;
            var HashedId8 v_digest;
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Wait for the message with the certificate to retrieve the AA digest.
            // Ask for the chain, containing AT and AA certificate
            // Check AA Certificate
            log("*** " & testcasename() & ": INFO: Wait for certificate and ask for certificate chain  ***");
            tc_ac.start;
            f_askForCertificateChain(f_generateDefaultCam());
            tc_ac.stop;
            
            // Test Body
            tc_ac.start;
            alt {
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwSecPdu(
                            mdw_securedMessage(
                                superset(
                                    mw_header_field_signer_info_certificate_chain(
                                        superset(
                                            mw_aa_certificate
                ))))))) {
                    tc_ac.stop;
                    log("*** " & testcasename() & ": PASS: AA certificate version set to " & int2char(c_certificate_version) & " ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                }
                [] geoNetworkingPort.receive(
                    mw_geoNwInd(
                        mw_geoNwSecPdu(
                            mdw_securedMessage(
                                superset(
                                    mw_header_field_signer_info_certificate_chain
                ))))) {
                    tc_ac.stop;
                    log("*** " & testcasename() & ": FAIL: AA certificate version mismatch or no AA cert received***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                [] tc_ac.timeout {
                    log("*** " & testcasename() & ": INCONC: Expected message not received ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout);
                }
            } // End of 'alt' statement
            
            // Postamble
            f_poNeighbour();
            f_cf01Down();
            
        } // End of testcase TC_SEC_SND_CERT_01_02
        
        /**
         * @desc    Check that the certificate chain is valid: Check signer_info 
         * <pre>
         * Pics Selection: none
         * Config Id: CF01
         * Initial conditions:
         * with {
         *   the IUT being in the 'authorized' state
         *   the IUT being requested to include certificate chain in the next CAM
         * } ensure that {
         *    when {
         *     the IUT is requested to send a CAM
         *   } then {
         *     the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *         containing type
         *           indicating certificate_chain
         *         containing certificates[N] {
         *           containing signer_info {
         *             containing type
         *               indicating 'certificate_digest_with_sha256'
         *             containing digest
         *               referenced to the certificates[N-1]
         *           }
         *         }
         *       }
         *   }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clause 6.1
         */
        testcase TC_SEC_SND_CERT_02_01() runs on ItsGeoNetworking system ItsSecSystem {
            // TODO: This TC is fully covered by TC_SEC_SND_CERT_09_02 
            // Local declarations
            var CertificateChain v_chain;
            var SignerInfo v_si;
            var HashedId8 v_digest;
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            log("*** " & testcasename() & ": INFO: Request and waiting for the message containing certificate chain  ***");
            tc_ac.start;
            if (not f_askAndWaitForCertificateChain(v_chain, f_generateDefaultCam())) {
                log("*** " & testcasename() & ": INCONC: Expected message not received ***");
                f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
            }
            tc_ac.stop;
            
            // Test Body
            for (var integer v_counter := lengthof(v_chain) - 1; v_counter > 0; v_counter := v_counter - 1) {                
                if (not f_getCertificateSignerInfo(v_chain[v_counter], v_si)) {
                    log("*** " & testcasename() & ": FAIL: Certificate " & int2str(v_counter) & " doesn't contain signer info ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                if (not match (v_si.type_, e_certificate_digest_with_sha256)) {
                    log("*** " & testcasename() & ": FAIL: Certificate is not signed with digest ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
                
                v_digest := f_calculateDigestFromCertificate(v_chain[v_counter - 1]);
                if (not match (v_si.signerInfo.digest, v_digest)) {
                    log("*** " & testcasename() & ": FAIL: Certificate chain is not valid ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                }
            } // End of 'for' statement
            log("*** " & testcasename() & ": PASS: Certificate chain is well signed ***");
            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
            
            // Postamble
            f_poNeighbour();
            f_cf01Down();
            
        } // End of testcase TC_SEC_SND_CERT_02_01
        
        /**
         * @desc Check that the length of the vector of rectangles is less then 6.
         *       Check that region is continuous and does not contain any holes.
         *       Check that the rectangles are valid  
         * <pre>
         * Pics Selection: PIC_UseRectangularRegion
         * Config Id: CF01
         * with {
         *   the IUT being in the 'authorized' state
         *   the IUT being requested to include certificate in the next CAM
         * } ensure that {
         *    when {
         *     the IUT is requested to send a CAM
         *   } then {
         *     the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *         containing type
         *           indicating 'certificate'
         *         containing certificate {
         *           containing no validity restriction or validity_restrictions['region']{
         *             containing region_type
         *               indicating 'rectangle'
         *             containing rectangular_region {
         *               indicating length <= 6
         *               containing elements of type RectangularRegion
         *                 indicating continuous region without holes
         *                 containing northwest and southeast
         *                   indicating northwest is on the north from southeast
         *             }
         *           }
         *         }
         *       }
         *   }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clauses 4.2.21, 4.2.24
         */
        testcase TC_SEC_SND_CERT_04_01() runs on ItsGeoNetworking system ItsSecSystem {
            // Local declarations
            var Certificate         v_cert;
            var ValidityRestriction v_vr;
            var integer             v_counter;
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Test body
            tc_ac.start;
            f_waitForCertificate(v_cert);
            tc_ac.stop;
            if (f_getCertificateValidityRestriction(v_cert, e_region, v_vr)) {
                if (v_vr.validity.region.region_type == e_rectangle) {
                    var RectangularRegions v_rects := v_vr.validity.region.region.rectangular_region;
                    if (lengthof(v_rects) > 6) {
                        log("*** " & testcasename() & ": FAIL: Rectangular regions count is more then 6 ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    for (v_counter := 0; v_counter<lengthof(v_rects); v_counter := v_counter + 1) {
                        var RectangularRegion v_rect := v_rects[v_counter];
                        if (true != f_isValidTwoDLocation(v_rect.northwest)) {
                            log("*** " & testcasename() & ": FAIL: Northwest location is invalid in rect " & int2str(v_counter) & " ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                        if (true != f_isValidTwoDLocation(v_rect.southeast)) {
                            log("*** " & testcasename() & ": FAIL: Southeast location is invalid in rect " & int2str(v_counter) & " ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                        // Check normality of the rectangle
                        if (v_rect.northwest.latitude < v_rect.southeast.latitude) {
                            log("*** " & testcasename() & ": FAIL: Rectangular region " & int2str(v_counter) & " is not normalized ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                    } // End of 'for' statement
                    
                    // Check for continuous rectangles
                    if (lengthof(v_rects) > 1) { 
                        if (true !=  f_isContinuousRectangularRegions(v_rects)) {
                            log("*** " & testcasename() & ": FAIL: Rectangular regions are not connected all together ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                    }
                } else {
                    log("*** " & testcasename() & ": INCONC: Certificate has other region type ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout); // to be inconc
                }
                
                log("*** " & testcasename() & ": PASS: Certificate has a valid rectangular region restrictions ***");
                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
            } else {
                log("*** " & testcasename() & ": PASS: Certificate doesn't have any location restrictions ***");
                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
            }
            
            // Postamble
            f_poNeighbour();
            f_cf01Down();
            
        } // End of testcase TC_SEC_SND_CERT_04_01
        
        /**
         * @desc Check that the rectangular region of the subordinate certificate is well formed 
         *       and inside the validity restrictions of the issuing certificate.  
         * <pre>
         * Pics Selection: PIC_UseRectangularRegion
         * Config Id: CF01
         * with {
         *     the IUT being in the 'authorized' state
         *     the IUT being requested to include certificate chain in the next CAM
         * } ensure that {
         *   when {
         *        the IUT is requested to send a CAM
         *      } then {
         *        the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *          containing type
         *            indicating 'certificate_chain'
         *         containing certificates
         *           indicating CERTIFICATES {
         *                containing CERTIFICATES[N] {
         *               containing validity_restrictions['region'] {
         *                 containing region_type
         *                   indicating 'rectangle'
         *                 containing rectangular_region {
         *                   indicating length <= 6
         *                   and containing elements of type RectangularRegion
         *                     containing northwest and southeast
         *                       indicating northwest  on the north from southeast
         *                   and indicating continuous region without holes
         *                     which is inside the CERTIFICATES[N-1].validity_restrictions['region'] if region validity restriction is containted in certificate CERTIFICATES[N-1]
         *                    }
         *                  }
         *             }
         *           }
         *       }
         *       }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clauses 4.2.21, 4.2.24
         */
        testcase TC_SEC_SND_CERT_04_02() runs on ItsGeoNetworking system ItsSecSystem {
            // Local declarations
            var CertificateChain    v_chain;
            var ValidityRestriction v_vr, v_vri;  // current and issuing cert validity restrictions
            var boolean f_vr, f_vri;
            
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            log("*** " & testcasename() & ": INFO: Request and waiting for the message containing certificate chain  ***");
            tc_ac.start;
            if (not f_askAndWaitForCertificateChain(v_chain, f_generateDefaultCam())) {
                log("*** " & testcasename() & ": INCONC: Expected message not received ***");
                f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
            }
            tc_ac.stop;
            
            // Test Body
            f_vr := false;
            for (var integer v_counter := 0; v_counter < lengthof(v_chain); v_counter := v_counter + 1) {
                v_vri := v_vr;
                f_vri := f_vr;
                f_vr := f_getCertificateValidityRestriction(v_chain[v_counter], e_region, v_vr);
                if (f_vr) {
                    var RectangularRegions v_rects;
                    if (v_vr.validity.region.region_type != e_rectangle) {
                        log("*** " & testcasename() & ": INCONC: Certificate validity restriction region is not rectangular ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    v_rects := v_vr.validity.region.region.rectangular_region;
                    if (lengthof(v_rects) > 6) {
                        log("*** " & testcasename() & ": FAIL: Rectangular regions count is more then 6 ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    for (var integer j:=0; j<lengthof(v_rects); j:=j + 1) {
                        var RectangularRegion v_rect := v_rects[j];
                        if (true != f_isValidTwoDLocation(v_rect.northwest)) {
                            log("*** " & testcasename() & ": FAIL: Northwest location is invalid in rect " & int2str(v_counter) & " ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                        if (true != f_isValidTwoDLocation(v_rect.southeast)) {
                            log("*** " & testcasename() & ": FAIL: Southeast location is invalid in rect " & int2str(v_counter) & " ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                        // Check normality of the rectangle
                        if (v_rect.northwest.latitude < v_rect.southeast.latitude) {
                            log("*** " & testcasename() & ": FAIL: Rectangle " & int2str(v_counter) & " is not normalized ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                    }
                    if (f_vri) {
                        // current restrictions must be inside of the parent one
                        if (not f_isRectangularRegionsInside(v_vri.validity.region.region.rectangular_region, v_rects)) {
                            log("*** " & testcasename() & ": FAIL: Certificate validity restriction region is not inside the issuing one ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                    }
                } else {
                    // Region validity restriction is not exist
                    if (f_vri) {
                        log("*** " & testcasename() & ": FAIL: Certificate validity restriction region must be set if thi restriction exists in the issuing certificate ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                }
            } // End of 'for' statement
                   
            log("*** " & testcasename() & ": PASS: All certificates has a valid rectangular region restrictions ***");
            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
            
            // Postamble
            f_poNeighbour();
            f_cf01Down();
            
        } // End of testcase TC_SEC_SND_CERT_04_02
        
        /**
         * @desc Check Polygonal Region:
         * Must contain at least 3 and no more then 12 points
         * Intersections and holes are not permited
         * <pre>
         * Pics Selection: PIC_UsePolygonalRegion
         * Config Id: CF01
         * with {
         *   the IUT being in the 'authorized' state
         *   the IUT being requested to include certificate in the next CAM
         * } ensure that {
         *    when {
         *     the IUT is requested to send a CAM
         *   } then {
         *     the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *         containing type
         *           indicating 'certificate'
         *         containing certificate {
         *           containing validity_restrictions['region']{
         *             containing region_type
         *               indicating 'polygon'
         *             containing polygonal_region {
         *               indicating length >=3 and <=12
         *               indicating continuous region without holes and intersections
         *             }
         *           }
         *         }
         *       }
         *   }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clauses 4.2.25
         */
        testcase TC_SEC_SND_CERT_05_01() runs on ItsGeoNetworking system ItsSecSystem {
            var Certificate         v_cert;
            var ValidityRestriction v_vr;
            var integer             v_counter;
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Test body
            tc_ac.start;
            f_waitForCertificate(v_cert);
            tc_ac.stop;
            if (f_getCertificateValidityRestriction(v_cert, e_region, v_vr)) { 
                if (v_vr.validity.region.region_type == e_polygon) {
                    var PolygonalRegion v_pr := v_vr.validity.region.region.polygonal_region;
                    var integer v_length := lengthof(v_pr);
                    if (v_length < 3) {
                        log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too small ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    if (v_length > 12) {
                        log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too big ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    if (true != f_isValidPolygonalRegion(v_pr)) {
                        log("*** " & testcasename() & ": FAIL: Polygonal region is not valid (self-intersected) ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    log("*** " & testcasename() & ": PASS: Certificate has a valid rectangular region restrictions ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                } else {
                    log("*** " & testcasename() & ": INCONC: Certificate has other region type ***");
                    f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_timeout); // to be inconc
                }
            } else {
                log("*** " & testcasename() & ": PASS: Certificate doesn't have any location restrictions ***");
                f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
            }
            
            // Postamble
            f_poNeighbour();
            f_cf01Down();
            
        } // End of testcase TC_SEC_SND_CERT_05_01

        /**
         * @desc Check Polygonal Region:
         * Must contain at least 3 and no more then 12 points.
         * Intersections and holes are not permited.
         * The region must be inside the issuing certificate restrictions.  
         * <pre>
         * Pics Selection: PIC_UsePolygonalRegion
         * Config Id: CF01
         * with {
         *   the IUT being in the 'authorized' state
         *   the IUT being requested to include certificate chain in the next CAM
         * } ensure that {
         *    when {
         *     the IUT is requested to send a CAM
         *   } then {
         *     the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *         containing type
         *           indicating 'certificate_chain'
         *         containing certificates
         *           indicating CERTIFICATES {
         *             containing CERTIFICATES[N] {
         *               containing validity_restrictions['region'] {
         *                 containing region_type
         *                   indicating 'polygon'
         *                 containing polygonal_region {
         *                   indicating length >=3 and <=12
         *                   indicating continuous region without holes and intersections
         *                     which is inside the CERTIFICATES[N-1].validity_restrictions['region'].polygonal_region 
         *                       if region validity restriction is containted in certificate CERTIFICATES[N-1]
         *                 }
         *               }
         *             }
         *           }
         *       }
         *   }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clauses 4.2.25
         */
        testcase TC_SEC_SND_CERT_05_02() runs on ItsGeoNetworking system ItsSecSystem {
            // Local declarations
            var CertificateChain    v_chain;
            var ValidityRestriction v_vr, v_vri;  // current and issuing cert validity restrictions
            var boolean f_vr, f_vri;
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Test Body
            log("*** " & testcasename() & ": INFO: Request and waiting for the message containing certificate chain  ***");
            tc_ac.start;
            if (not f_askAndWaitForCertificateChain(v_chain, f_generateDefaultCam())) {
                log("*** " & testcasename() & ": INCONC: Expected message not received ***");
                f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
            }
            tc_ac.stop;
            f_vr := false;
            for (var integer v_counter := 0; v_counter < lengthof(v_chain); v_counter := v_counter + 1) {
                v_vri := v_vr;
                f_vri := f_vr;
                f_vr := f_getCertificateValidityRestriction(v_chain[v_counter], e_region, v_vr);
                if (f_vr) {
                    var PolygonalRegion v_pr;
                    var integer v_length;
                    
                    if (v_vr.validity.region.region_type != e_polygon) {
                        log("*** " & testcasename() & ": INCONC: Certificate validity restriction region is not polygonal ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    
                    v_pr := v_vr.validity.region.region.polygonal_region;
                    v_length := lengthof(v_pr);
                    
                    if (v_length < 3) {
                        log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too small in cert " & int2str(v_counter) & " ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    
                    if (v_length > 12) {
                        log("*** " & testcasename() & ": FAIL: Count of points in polygonal region is too big  in cert " & int2str(v_counter) & "***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    
                    if (true != f_isValidPolygonalRegion(v_pr)) {
                        log("*** " & testcasename() & ": FAIL: Polygonal region is not valid (self-intersected) in cert " & int2str(v_counter) & " ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                    
                    if (f_vri) {
                        // current restrictions must be inside of the parent one
                        if (true != f_isPolygonalRegionInside(v_vri.validity.region.region.polygonal_region, v_pr)) {
                            log("*** " & testcasename() & ": FAIL: Certificate validity restriction region in cert " & int2str(v_counter) & " is not inside the issuing one ***");
                            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                        }
                    }
                } else {
                    // Region validity restriction is not exist
                    if (f_vri) {
                        log("*** " & testcasename() & ": FAIL: Certificate validity restriction region must be set in the certificate "  & int2str(v_counter) &
                                                              "because this restriction exists in the issuing certificate ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                }
            } // End of 'for' statement
            
            log("*** " & testcasename() & ": PASS: All certificates has a valid polygonal region restrictions ***");
            f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
            
            // Postamble
            f_poNeighbour();
            f_cf01Down();
            
        } // End of testcase TC_SEC_SND_CERT_05_02

        /**
         * @desc Check Identified Region:
         * Must contain value that correspond to numeric country codes as defined in ISO 3166-1 
         * <pre>
         * Pics Selection: PIC_UseIdentifiedRegion, PIC_UseISO31661RegionDictionary
         * Config Id: CF01
         * with {
         *   the IUT being in the 'authorized' state
         *   the IUT being requested to include certificate in the next CAM
         * } ensure that {
         *    when {
         *     the IUT is requested to send a CAM
         *   } then {
         *     the IUT sends a SecuredMessage
         *       containing header_fields['signer_info'].signer {
         *         containing type
         *           indicating 'certificate'
         *         containing certificate {
         *           containing validity_restrictions['region']{
         *             containing region_type
         *               indicating 'id'
         *             containing id_region {
         *               containing region_dictionary
         *                 indicating 'iso_3166_1' (0)
         *               containing region_identifier
         *                 indicating valid value according to 'iso_3166_1'
         *               containing local_region
         *             }
         *           }
         *         }
         *       }
         *   }
         * }
         * </pre>
         * @reference ETSI TS 103 097 V1.1.14, clauses 4.2.27
         */
        testcase TC_SEC_SND_CERT_06_01() runs on ItsGeoNetworking system ItsSecSystem {
            var Certificate         v_cert;
            var ValidityRestriction v_vr;
            var integer             v_counter;
            
            // Test component configuration
            f_cf01Up();
            
            // Preamble
            f_prNeighbour();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Test body
            tc_ac.start;
            f_waitForCertificate(v_cert);
            tc_ac.stop;
            if (f_getCertificateValidityRestriction(v_cert, e_region, v_vr)) {
                if (v_vr.validity.region.region_type == e_id) {
                    if (not match (v_vr.validity.region, mw_geographicRegion_identified(mw_identifiedRegion_iso3166_any))) {
                        log("*** " & testcasename() & ": FAIL: Identified region is not conformed to ISO 3166-1 ***");
                        f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                    }
                }