ItsPkiItss_TestCases.ttcn

       *         then {
       *             the IUT switches to the "enrolled" state
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 v2.0.1 SECPKI_ITSS_ENR_RECV_02_BV
       * @reference ETSI TS 102 941, clause 6.1.3, 6.2.3.2.1
       */
      testcase TC_SECPKI_ITSS_ENR_RECV_02_BV() runs on ItsMtc system ItsPkiItssSystem {
        // Local variables
        var ItsPkiItss v_itss;
        var ItsPkiHttp v_ea;

        // Test control
        if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT) {
          log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT required for executing the TC ***");
          setverdict(inconc);
          stop;
        }

        // Test component configuration
        f_cfMtcUp01(v_itss, v_ea);

        // Start component
        v_itss.start(f_TC_SECPKI_ITSS_ENR_RECV_02_BV_itss());
        v_ea.start(f_TC_SECPKI_ITSS_ENR_RECV_02_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);

      } // End of testcase TC_SECPKI_ITSS_ENR_RECV_02_BV

      group f_TC_SECPKI_ITSS_ENR_RECV_02_BV {

        function f_TC_SECPKI_ITSS_ENR_RECV_02_BV_itss() runs on ItsPkiItss system ItsPkiItssSystem {
          // Local variables
          var HashedId8               v_certificate_digest;
          var EtsiTs103097Certificate v_certificate;
          var boolean                 v_iut_state_ok := false;

          // Test component configuration
//TODO:DELETE          vc_hashedId8ToBeUsed := ""; // No certificates //PX_IUT_DEFAULT_CERTIFICATE
          f_cfUp_itss();

          // Test adapter configuration

          // Preamble
          // Initial state: No CAM shall be emitted
          geoNetworkingPort.clear;
          tc_noac.start;
          alt {
            [] geoNetworkingPort.receive {
              log("No CA message expected");
              f_selfOrClientSyncAndVerdict(c_prDone, e_error);
            }
            [] tc_noac.timeout {
              f_sendUtTriggerEnrolmentRequestPrimitive();
              log("*** " & testcasename() & "_itss: : INFO: No CA message received ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            }
          } // End of 'alt' statement

          // Test Body
          tc_ac.start; // TDOD To refined, use altstep
          alt {
            [] utPort.receive(UtPkiTriggerInd: { state := 1 }) {
              tc_ac.stop;
              v_iut_state_ok := true;
              log("*** " & testcasename() & "_itss: INFO: IUT is in enrol state ***");
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & "_itss: DBG: IUT state update not recieved ***");
              //f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement
          tc_noac.start;
          alt {
            [] geoNetworkingPort.receive {
              log("No CA message expected");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
            }
            [] tc_noac.timeout {
              if (v_iut_state_ok == true) {
                log("*** " & testcasename() & "_itss: : PASS: Enrolment trigger processed succesfully ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
              } else {
                log("Did not receive IUT state update");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
              }
            }
          } // End of 'alt' statement

          // Postamble
          f_cfDown_itss();
        } // End of function f_TC_SECPKI_ITSS_ENR_RECV_02_BV_itss

        function f_TC_SECPKI_ITSS_ENR_RECV_02_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;

          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);

          // Test adapter configuration

          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);
          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(
                                                mw_http_request(
                                                                mw_http_request_post(
                                                                                     PICS_HTTP_POST_URI_EC,
                                                                                     -,
                                                                                     mw_http_message_body_binary(
                                                                                                                 mw_binary_body_ieee1609dot2_data(
                                                                                                                                                  mw_enrolmentRequestMessage(
                                                                                                                                                                            mw_encryptedData(
                                                                                                                                                                                             { *, mw_recipientInfo_certRecipInfo(mw_pKRecipientInfo(vc_eaHashedId8)), * },
                                                                                                                                                                                             mw_symmetricCiphertext_aes128ccm
                                                                                                                                                                                             )))))),
                                                v_request
                                                ) {
              var HttpMessage v_response;
              var integer v_result;
              var InnerEcRequest v_inner_ec_request;
              var InnerEcResponse v_inner_ec_response;

              tc_ac.stop;

              // Verify IUT response
              f_verify_http_ec_request_from_iut_itss(v_request.request, v_headers, v_inner_ec_request, v_inner_ec_response, v_response, v_result);
              // Send response forcing error code
              if (isvalue(v_response)) {
                httpPort.send(v_response);
              }
              // Set verdict
              if (v_result == 0) {
                log("*** " & testcasename() & ": INFO: InnerEcRequest received ***");
                f_selfOrClientSyncAndVerdict(c_prDone, e_success);
              } else {
                log("*** " & testcasename() & ": FAIL: Failed to verify EA an EnrolmentRequestMessage ***");
                f_selfOrClientSyncAndVerdict(c_prDone, e_error);
              }
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: Expected message not received ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_timeout);
            }
          } // End of 'alt' statement

          // Test Body
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);

          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_RECV_02_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_RECV_02_BV

    } // End of group itss_enrolment_response

    // ETSI TS 103 525-2 V2.0.2 (2023-07) Clause 5.2.2.3  Enrollment request repetition
    group itss_enrollment_request_repetition {

      /**
       * @desc Check that IUT repeats an enrollment request when response has not been received
       * <pre>
       * Pics Selection: PICS_SECPKI_ENROLLMENT_RETRY
       * Initial conditions: {
       *     the IUT being in the 'initialized' state
       *     and the IUT already sent the Enrollment Request at the time T1
       *     and the IUT has not yet received the Enrollment Response
       *     }
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT local time is reached the T1 + PIXIT_ENR_TIMEOUT_TH1  
       *         }
       *         then {
       *             the IUT sends to EA an EnrollmentRequestMessage
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 TP SECPKI_ITSS_ENR_REP_01_BV
       * @reference ETSI TS 103 601, clause 5.1.2
       */
      group g_TC_SECPKI_ITSS_ENR_REP_01_BV {

        testcase TC_SECPKI_ITSS_ENR_REP_01_BV() runs on ItsMtc system ItsPkiItssSystem {
          // Local variables
          var ItsPkiItss v_itss;
          var ItsPkiHttp v_ea;

          // Test control
          if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT or not PICS_SECPKI_ENROLLMENT_RETRY) {
            log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT or PICS_SECPKI_ENROLLMENT_RETRY required for executing the TC ***");
            setverdict(inconc);
            stop;
          }

          // Test component configuration
          f_cfMtcUp01(v_itss, v_ea);

          // Start component
          v_itss.start(f_TC_SECPKI_ITSS_ENR_REP_01_BV_itss());
          v_ea.start(f_TC_SECPKI_ITSS_ENR_REP_01_BV_pki());

          // Synchronization
          f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

          // Cleanup
          f_cfMtcDown01(v_itss, v_ea);

        } // End of testcase TC_SECPKI_ITSS_ENR_REP_01_BV

        function f_TC_SECPKI_ITSS_ENR_REP_01_BV_itss()
             runs on ItsPkiItss system ItsPkiItssSystem {
          // Test component configuration
          f_cfUp_itss(); // No IT certificate selected

          // Test adapter configuration

          // Preamble
          // Initial state: No CAM shall be emitted
          geoNetworkingPort.clear;
          tc_noac.start;
          alt {
            [] geoNetworkingPort.receive {
              log("*** " & testcasename() & "_itss: ERROR: Unexpected GeoNet message received ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_error);
              }
            [] tc_noac.timeout {
              // Trigger the first enrolment
              log("*** " & testcasename() & "_itss: INFO: No GeoNet message received. Continue ***");
              f_sendUtTriggerEnrolmentRequestPrimitive(-, -, -, -, -, false);
              f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            }
          } // End of 'alt' statement

          // Test Body
          // Nothing to do in test body. Just wait for ENR repetition in PKI component          
          f_selfOrClientSyncAndVerdict(c_tbDone, e_success);

          // Postamble
          f_cfDown_itss();
        } // End of function f_TC_SECPKI_ITSS_ENR_REP_01_BV_itss

        function f_TC_SECPKI_ITSS_ENR_REP_01_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_initial_request;
          var HttpMessage v_request;

          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);

          // Test adapter configuration

          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);

          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request) {
              log("*** " & testcasename() & ": INFO: First enrolment request received ***");
              tc_ac.stop;
              f_http_restart("inner_ec_request");
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: First enrolment request not received ***");
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_timeout);
            }
          } // End of 'alt' statement

          f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
  
          // Test Body
          tc_wait.start(PX_EC_REPETITION_TIMEOUT);
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request) {
              log("*** " & testcasename() & ": PASS: EC repetition has been received after a ", tc_wait.read, " ***");
              tc_wait.stop;
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }
            [] tc_wait.timeout {
              log("*** " & testcasename() & ": FAIL: EC repetition was not received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
            }
          }
          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_REP_01_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_REP_01_BV

      /**
       * @desc Check that IUT uses the same message to perform enrollment retry
       * <pre>
       * Pics Selection: PICS_SECPKI_ENROLLMENT_RETRY
       * Initial conditions: {
       *     the IUT being in the 'initialized' state
       *     and the IUT already sent the Enrollment Request (M)
       *     }
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT is triggered to re-send an Enrollment Request 
       *         }
       *         then {
       *             the IUT sends M to EA
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 TP SECPKI_ITSS_ENR_REP_02_BV
       * @reference ETSI TS 103 601, clause 5.1.2
       */
      group f_TC_SECPKI_ITSS_ENR_REP_02_BV {
        testcase TC_SECPKI_ITSS_ENR_REP_02_BV() runs on ItsMtc system ItsPkiItssSystem {
          // Local variables
          var ItsPkiItss v_itss;
          var ItsPkiHttp v_ea;
          
          // Test control
          if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT or not PICS_SECPKI_ENROLLMENT_RETRY) {
            log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT or PICS_SECPKI_ENROLLMENT_RETRY required for executing the TC ***");
            setverdict(inconc);
            stop;
          }
          
          // Test component configuration
          f_cfMtcUp01(v_itss, v_ea);
          
          // Start component
          v_itss.start(f_TC_SECPKI_ITSS_ENR_REP_01_BV_itss());
          v_ea.start(f_TC_SECPKI_ITSS_ENR_REP_02_BV_pki());
          
          // Synchronization
          f_serverSync2ClientsAndStop({c_prDone, c_tbDone});
          
          // Cleanup
          f_cfMtcDown01(v_itss, v_ea);
          
        } // End of testcase TC_SECPKI_ITSS_ENR_REP_02_BV
              
        function f_TC_SECPKI_ITSS_ENR_REP_02_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request1;
          var HttpMessage v_request2;

          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);

          // Test adapter configuration

          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);
          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request1) {
              log("*** " & testcasename() & ": INFO: First enrolment request received ***");
              tc_ac.stop;
              f_http_restart("inner_ec_request");
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: First enrolment request not received ***");
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_timeout);
            }
          } // End of 'alt' statement
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          
          // Test Body          
          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(
                                      mw_http_request(
                                            mw_http_request_post(
                                                    PICS_HTTP_POST_URI_EC,
                                                    -,
                                                    v_request1.request.body)),

                                      v_request2)
            {
              tc_ac.stop;
              log("*** " & testcasename() & ": PASS: Same enrolment request received ***");
              // send error respond to prevent future requests
              f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_success);
            }
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request2) {
              tc_ac.stop;
              log("*** " & testcasename() & ": FAIL: 2nd enrolment request is not identical ***");
              f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_error);
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: First enrolment request not received ***");
              f_selfOrClientSyncAndVerdictPreamble(c_tbDone, e_timeout);
            }
          } // End of 'alt' statement

          f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);

          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_REP_02_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_REP_02_BV

      /**
       * @desc Check that IUT stops sending the Enrollment Request message if Enrollment Response message has been received
       * <pre>
       * Pics Selection: PICS_SECPKI_ENROLLMENT_RETRY
       * Initial conditions: {
       *     the IUT being in the 'initialized' state
       *     and the IUT has sent the Enrollment Request more than 1 time
       *     }
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT receives an Enrollment Response
       *         }
       *         then {
       *             the IUT stops sending Enrollment Requests to EA
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 TP SECPKI_ITSS_ENR_REP_03_BV
       * @reference ETSI TS 103 601, clause 5.1.2
       */
      testcase TC_SECPKI_ITSS_ENR_REP_03_BV() runs on ItsMtc system ItsPkiItssSystem {
        // Local variables
        var ItsPkiItss v_itss;
        var ItsPkiHttp v_ea;

        // Test control
        if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT or not PICS_SECPKI_ENROLLMENT_RETRY) {
          log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT or PICS_SECPKI_ENROLLMENT_RETRY required for executing the TC ***");
          setverdict(inconc);
          stop;
        }

        // Test component configuration
        f_cfMtcUp01(v_itss, v_ea);

        // Start component
        v_itss.start(f_TC_SECPKI_ITSS_ENR_REP_01_BV_itss());
        v_ea.start(f_TC_SECPKI_ITSS_ENR_REP_03_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);

      } // End of testcase TC_SECPKI_ITSS_ENR_REP_03_BV
      
      group f_TC_SECPKI_ITSS_ENR_REP_03_BV {
        
        function f_TC_SECPKI_ITSS_ENR_REP_03_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          var HttpMessage v_initial_request;
          var integer v_rep_count := 0;
          var integer c_rep_answer := 2; // answer to the n-th request repetition

          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);

          // Test adapter configuration

          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);
          
          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_initial_request) {
              log("*** " & testcasename() & ": INFO: First enrolment request received ***");
              tc_ac.stop;
              f_http_restart("inner_ec_request");
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: First enrolment request not received ***");
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_timeout);
            }
          } // End of 'alt' statement

          f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);

          // Test Body
          tc_ac.start;
          alt {
            // match initial request
            [] a_await_ec_http_request_from_iut(
                                                mw_http_ec_request_generic(
                                                                            v_initial_request.request.body.binary_body.ieee1609dot2_data
                                                                          ), 
                                                v_request
                                                ) {
              v_rep_count := v_rep_count + 1;
              tc_ac.stop;
              if (v_rep_count < c_rep_answer) {
                // skip repetition
                log("*** " & testcasename() & ": ", v_rep_count, " EC repetition has been received. Continue ***");
                f_http_restart("inner_ec_request");
                tc_ac.start;
                repeat;
              }
              
              if(v_rep_count == c_rep_answer) {
                // answer this repetition
                log("*** " & testcasename() & ": ", v_rep_count, " EC repetition has been received. Respond ***");
                var InnerEcRequest v_inner_ec_request;
                var InnerEcResponse v_inner_ec_response;
                var HttpMessage v_response;
                var integer v_result;

                f_verify_http_ec_request_from_iut_itss(v_request.request, v_headers, v_inner_ec_request, v_inner_ec_response, v_response, v_result);
                // Send response
                if (isvalue(v_response)) {
                  httpPort.send(v_response);
                } else { // Send HTTP error 500
                  f_send_500_Internal_Error(v_headers);
                }
                // Set verdict
                if (v_result == 0) {
                  log("*** " & testcasename() & ": PASS: InnerEcRequest received ***");
                } else {
                  log("*** " & testcasename() & ": FAIL: Failed to verify EA an EnrolmentRequestMessage ***");
                }  
                repeat;
              }

              // repetition request received after sending the response
              log("*** " & testcasename() & ": FAIL: Repetition request received after response ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_error);  
            }                                     
            [] a_await_ec_http_request_from_iut( mw_http_ec_request_generic, v_request ) {
              tc_ac.stop;
              f_send_500_Internal_Error(v_headers);
              log("*** " & testcasename() & ": INCONC: New request received during repetition period ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
            }
            [] tc_ac.timeout {
              if(v_rep_count < c_rep_answer) {
                log("*** " & testcasename() & ": INCONC: Timeout occured during the repetition period ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
              }
              
              log("*** " & testcasename() & ": PASS: EC repetition request was not received after response ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }
          } // End of alt statment

          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_REP_03_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_REP_03_BV

      /**
       * @desc Check that IUT stops sending the Enrollment Request message if maximum number of retry has been reached
       * <pre>
       * Pics Selection: PICS_SECPKI_ENROLLMENT_RETRY
       * Initial conditions: {
       *     the IUT being in the 'initialized' state
       *     and the IUT has started sending the Enrollment Request
       *     }
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT sent the PIXIT_ENR_MAX_N1 Enrollment Request messages
       *         }
       *         then {
       *             the IUT stops sending Enrollment Requests
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 TP SECPKI_ITSS_ENR_REP_04_BV
       * @reference ETSI TS 103 601, clause 5.1.2
       */
      testcase TC_SECPKI_ITSS_ENR_REP_04_BV() runs on ItsMtc system ItsPkiItssSystem {
        // Local variables
        var ItsPkiItss v_itss;
        var ItsPkiHttp v_ea;

        // Test control
        if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT or not PICS_SECPKI_ENROLLMENT_RETRY) {
          log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT or PICS_SECPKI_ENROLLMENT_RETRY required for executing the TC ***");
          setverdict(inconc);
          stop;
        }

        // Test component configuration
        f_cfMtcUp01(v_itss, v_ea);

        // Start component
        v_itss.start(f_TC_SECPKI_ITSS_ENR_REP_01_BV_itss());
        v_ea.start(f_TC_SECPKI_ITSS_ENR_REP_04_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);

      } // End of testcase TC_SECPKI_ITSS_ENR_REP_04_BV  

      group f_TC_SECPKI_ITSS_ENR_REP_04_BV {

        function f_TC_SECPKI_ITSS_ENR_REP_04_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_initial_request;
          var HttpMessage v_request;
          var integer v_count := 0;

          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);

          // Test adapter configuration

          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);
          f_selfOrClientSyncAndVerdict(c_prDone, e_success);

          // Test Body
          tc_ac.start;
          alt{
            [v_count <= PX_ENR_MAX_N1] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_initial_request) {
              v_count := v_count + 1;
              repeat;
            }
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_initial_request){
              // count exceed
              log("*** " & testcasename() & ": FAIL: Too many repetitions of Enrolment requests received ***");
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_error);
            }
            [] tc_ac.timeout{
              if(v_count > PX_ENR_MAX_N1){
                log("*** " & testcasename() & ": PASS: Maximum number of Enrollment request repetitions received ***");
                f_selfOrClientSyncAndVerdict(c_prDone, e_success);
              } else {
                log("*** " & testcasename() & ": INCONC: Expected message not received ***");
                f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);             
              }
            }
          }
          // Postamble
          f_cfHttpDown();

        } // End of function f_TC_SECPKI_ITSS_ENR_REP_04_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_REP_04_BV

      /**
       * @desc Check that IUT stops sending the Enrollment Request message if timeout has been reached
       * <pre>
       * Pics Selection: PICS_SECPKI_ENROLLMENT_RETRY
       * Initial conditions: {
       *     the IUT being in the 'initialized' state
       *     and the IUT has started sending the Enrollment Request at the time T1
       *     }
       * Expected behaviour:
       *     ensure that {
       *         when {
       *             the IUT sent the PIXIT_ENR_TIMEOUT_TH2 Enrollment Request messages
       *         }
       *         then {
       *             the IUT stops sending an Enrollment Request messages
       *         }
       *     }
       * </pre>
       * 
       * @see       ETSI TS 103 525-2 TP SECPKI_ITSS_ENR_REP_05_BV
       * @reference ETSI TS 103 601, clause 5.1.2
       */
      testcase TC_SECPKI_ITSS_ENR_REP_05_BV() runs on ItsMtc system ItsPkiItssSystem {
        // Local variables
        var ItsPkiItss v_itss;
        var ItsPkiHttp v_ea;

        // Test control
        if (not PICS_IUT_ITS_S_ROLE or not PICS_SECPKI_ENROLMENT or not PICS_SECPKI_ENROLLMENT_RETRY) {
          log("*** " & testcasename() & ": PICS_IUT_ITS_S_ROLE and PICS_SECPKI_ENROLMENT or PICS_SECPKI_ENROLLMENT_RETRY required for executing the TC ***");
          setverdict(inconc);
          stop;
        }

        // Test component configuration
        f_cfMtcUp01(v_itss, v_ea);

        // Start component
        v_itss.start(f_TC_SECPKI_ITSS_ENR_REP_01_BV_itss());
        v_ea.start(f_TC_SECPKI_ITSS_ENR_REP_05_BV_pki());

        // Synchronization
        f_serverSync2ClientsAndStop({c_prDone, c_tbDone});

        // Cleanup
        f_cfMtcDown01(v_itss, v_ea);

      } // End of testcase TC_SECPKI_ITSS_ENR_REP_05_BV

      group f_TC_SECPKI_ITSS_ENR_REP_05_BV {

        function f_TC_SECPKI_ITSS_ENR_REP_05_BV_pki() runs on ItsPkiHttp system ItsPkiItssSystem {
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          var HttpMessage v_initial_request;

          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);

          // Test adapter configuration

          // Preamble
          f_init_default_headers_list(-, "inner_ec_response", v_headers);

          tc_ac.start;
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_initial_request) {
              log("*** " & testcasename() & ": INFO: First enrolment request received ***");
              tc_ac.stop;
              f_http_restart("inner_ec_request");
            }
            [] tc_ac.timeout {
              log("*** " & testcasename() & ": INCONC: First enrolment request not received ***");
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_timeout);
            }
          } // End of 'alt' statement

          f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
          // Test body
          tc_wait.start(PX_EC_REPETITION_TIMEOUT_TH2);
          alt {
            [] a_await_ec_http_request_from_iut(mw_http_ec_request_generic, v_request) {
              log("*** " & testcasename() & ": FAIL: No EC repetition should be received ***");
              tc_wait.stop;
              f_selfOrClientSyncAndVerdict(c_tbDone, e_error);
            }
            [] tc_wait.timeout {
              log("*** " & testcasename() & ": PASS: EC repetition not received ***");
              f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
            }
          }

          // Postamble
          f_cfHttpDown();
        } // End of function f_TC_SECPKI_ITSS_ENR_REP_05_BV_pki

      } // End of group f_TC_SECPKI_ITSS_ENR_REP_05_BV
      
    } // End of group itss_enrollment_request_repetition

    // ETSI TS 103 525-2 V2.0.2 (2023-07) Clause 5.2.3.1  Authorization request
    group itss_authorization_request {

        function f_TC_SECPKI_ITSS_AUTH_itss(
                                            in integer p_execution_count := 1,
                                            in boolean p_force_enrolment := PX_TRIGGER_EC_BEFORE_AT
        ) runs on ItsPkiItss system ItsPkiItssSystem {
          // Local variables
          f_cfUp_itss();

          // Test adapter configuration

          // Preamble
          // Initial state: No CAM shall be emitted
          geoNetworkingPort.clear;
          tc_noac.start;
          alt {
            [] geoNetworkingPort.receive {
              log("No CA message expected");
              f_selfOrClientSyncAndVerdict(c_prDone, e_error);
            }
            [] tc_noac.timeout {
              log("*** " & testcasename() & "_itss: : INFO: No CA message received ***");
              if (p_force_enrolment) {
                f_sendUtTriggerEnrolmentRequestPrimitive();
                tc_ac.start;
                alt {
                  [] utPort.receive(UtPkiTriggerInd: { state := 1 }) {
                    tc_ac.stop;
                    log("*** " & testcasename() & "_itss: INFO: IUT is in enrol state ***");
                  }
                  [LibItsPki_Pics.PICS_UT_STATE_INDICATION ] tc_ac.timeout {
                    log("*** " & testcasename() & "_itss: DBG: IUT state update not recieved ***");
                    f_selfOrClientSyncAndVerdict(c_tbDone, e_timeout);
                  }
                  [not LibItsPki_Pics.PICS_UT_STATE_INDICATION ] tc_ac.timeout {
                    log("*** " & testcasename() & "_itss: DBG: IUT doesn't support state indication. Assume it was well done.***");
                  }
                } // End of 'alt' statement
              } else {
                log("*** " & testcasename() & "_itss: DBG: Assume IUT already in enrolled state.***");
              }
              f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            }
          } // End of 'alt' statement

          // Test Body
          var integer v_i := 0;
          label l_repeat;
          log("*** " & testcasename() & "_itss: DBG: Send UT Authorisation request " & int2str(v_i) & " out of " & int2str(p_execution_count) & ". ***");
          f_sendUtTriggerAuthorizationRequestPrimitive();
          v_i := v_i + 1;
          if( v_i < p_execution_count ){
            log("*** " & testcasename() & "_itss: Sync on " & c_nextTry & ". ***");
            f_clientSync(c_nextTry , e_success );
            f_sleep ( 1.0 );
            goto l_repeat;
          }
          log("*** " & testcasename() & "_itss: Success. ***");
          f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);

          // Postamble
          f_cfDown_itss();
        } // End of function f_TC_SECPKI_ITSS_AUTH_04_BV_itss

        type record TC_SECPKI_ITSS_AUTH_04_BV_pki_test_data {
          OctSet nonces,
          OctSet symmKeys
        };
        type set of PublicVerificationKey SetOfPublicVerificationKey;
        type set of BasePublicEncryptionKey SetOfPublicEncryptionKey;

        type record TC_SECPKI_ITSS_AUTH_06_BV_pki_test_data {
          SetOfPublicVerificationKey vKeys,
          SetOfPublicEncryptionKey eKeys,
          OctSet hmacKeys
        };

        type record SECPKI_ITSS_TestData {
          integer counter,
          Oct16   aesKey,
          union {
            integer none_,
            TC_SECPKI_ITSS_AUTH_04_BV_pki_test_data tc04,
            TC_SECPKI_ITSS_AUTH_06_BV_pki_test_data tc06
          } anyData
        };
        const SECPKI_ITSS_TestData SECPKI_ITSS_TestData_init_value := {0, '00000000000000000000000000000000'O, {none_:=0}};

        type function F_Test_Ieee1609Dot2Data (inout SECPKI_ITSS_TestData p_data, in Ieee1609Dot2Data p_value)
             runs on ItsPkiHttp return boolean;
        type function F_Test_EtsiTs102941Data (inout SECPKI_ITSS_TestData p_data,  in EtsiTs102941Data p_value)
             runs on ItsPkiHttp return boolean;
        
        function f_TC_SECPKI_ITSS_AUTH_pki_simple(
          in SECPKI_ITSS_TestData p_data := SECPKI_ITSS_TestData_init_value,//< Data to be sent to callbacks
          in F_Test_Ieee1609Dot2Data pf_test_encryptedData := null, //< function to be called when outer message is decrypted
          in F_Test_Ieee1609Dot2Data pf_test_signedData := null,    //< function to be called to test signed data
          in F_Test_EtsiTs102941Data pf_test_pkiRequest := null,    //< function to be called to test pki request

          in integer p_execution_count := 1,                        //< count of messages to be tested
          in boolean p_force_enrolment := PX_TRIGGER_EC_BEFORE_AT,
          in template (present) HttpMessage  pmw_at_request := mw_http_at_request_generic,
          in AuthorizationResponseCode p_responseCode := ok          

        ) runs on ItsPkiHttp system ItsPkiItssSystem {
          // Test component configuration
          f_cfHttpUp(PICS_TS_EA_CERTIFICATE_ID, PICS_TS_AA_CERTIFICATE_ID);
          f_TC_SECPKI_ITSS_AUTH_pki(p_data, pf_test_encryptedData, pf_test_signedData, pf_test_pkiRequest,
                                    p_execution_count, p_force_enrolment, pmw_at_request, p_responseCode);
          f_cfHttpDown();
        }

        function f_TC_SECPKI_ITSS_AUTH_pki(
          inout SECPKI_ITSS_TestData p_data,                        //< Data to be sent to callbacks
          in F_Test_Ieee1609Dot2Data pf_test_encryptedData := null, //< function to be called when outer message is decrypted
          in F_Test_Ieee1609Dot2Data pf_test_signedData := null,    //< function to be called to test signed data
          in F_Test_EtsiTs102941Data pf_test_pkiRequest := null,    //< function to be called to test pki request

          in integer p_execution_count := 1,                        //< count of messages to be tested
          in boolean p_force_enrolment := PX_TRIGGER_EC_BEFORE_AT,
          in template (present) HttpMessage  pmw_at_request := mw_http_at_request_generic,
          in AuthorizationResponseCode p_responseCode := ok          
        
        ) runs on ItsPkiHttp system ItsPkiItssSystem {
        
          // Local variable
          var Headers v_headers;
          var HttpMessage v_request;
          var HttpMessage v_response;
          var InnerAtRequest v_inner_at_request;

          // Preamble
          f_init_default_headers_list(-, "inner_at_response", v_headers);
          if (p_force_enrolment) {
            var InnerEcRequest v_inner_ec_request;
            var InnerEcResponse v_inner_ec_response;
            if (f_await_ec_request_send_response(v_inner_ec_request, v_inner_ec_response, v_request) == true) {
              log("*** " & testcasename() & ": INFO: Enrolment succeed ***");
              f_selfOrClientSyncAndVerdict(c_prDone, e_success);
            } else {
              log("*** " & testcasename() & ": INCONC: Enrolment failed ***");
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_timeout);
            }
          } else {
            f_selfOrClientSyncAndVerdict(c_prDone, e_success);
          }

          // Test body
          var charstring c_interSyncPoint;
          if (p_execution_count > 1) { c_interSyncPoint := c_nextTry; }
          else                       { c_interSyncPoint := c_tbDone; }
          p_data.counter := 0;
          log("*** " & testcasename() & ": Wait for Authorization message " & int2str(p_data.counter) & " ***");
          tc_ac.start;
          alt {
            [] a_await_at_http_request_from_iut(pmw_at_request, v_request) {
              var Oct16 v_request_hash;
              var Ieee1609Dot2Data v_request_message_signed;
              var Ieee1609Dot2Data v_response_message;
              var EtsiTs102941Data v_pki_request;
              var InnerAtResponse v_at_response;
              var boolean v_result;

              tc_ac.stop;

              if( pf_test_encryptedData != null ){
                if( not pf_test_encryptedData.apply( p_data, v_request.request.body.binary_body.ieee1609dot2_data )){
                  log("*** " & testcasename() & ": FAIL: Encrypted data check failed ***");
                  f_send_500_Internal_Error(v_headers);
                  f_selfOrClientSyncAndVerdict(c_interSyncPoint, e_error);
                }
              }

              if(pf_test_signedData == null and pf_test_pkiRequest == null) {
                // don't need to parse the rest of the message
                f_send_500_Internal_Error(v_headers);
              } else {
                v_result := f_read_pki_request_message (
                                                        v_request.request.body.binary_body.ieee1609dot2_data,
                                                        vc_aaPrivateEncKey, vc_aaWholeHash,
                                                        v_request_hash, p_data.aesKey,
                                                        v_request_message_signed, 
                                                        v_pki_request);
                
                if( isbound(v_request_message_signed) ){
                  if(pf_test_signedData != null){
                    v_result := pf_test_signedData.apply(p_data, v_request_message_signed );
                  }
                }
                
                if(not v_result) {
                  log("*** " & testcasename() & ": FAIL: Can't parse Auth request ***");
                  f_send_500_Internal_Error(v_headers);
                  f_selfOrClientSyncAndVerdict(c_interSyncPoint, e_error);
                }

                log("*** " & testcasename() & ": The " & int2str(p_data.counter) & " Authorization message received ***");

                var template (omit) InnerAtRequest v_innerAtRequest := omit;
                
                if(pf_test_pkiRequest != null){
                  // send response to prevent auth repetition
                  if( ischosen ( v_pki_request.content.authorizationRequest ) ) {
                    v_innerAtRequest := v_pki_request.content.authorizationRequest;
                  }
                }
                if(p_responseCode == ok and not isvalue(v_innerAtRequest)){
                  p_responseCode := its_aa_cantparse;
                }

                if( not f_http_build_authorization_response ( v_innerAtRequest , p_responseCode , 
                                                              v_request_hash,
                                                              vc_aaPrivateKey, vc_aaWholeHash, p_data.aesKey,
                                                              v_at_response, v_response_message) )
                {
                  f_send_500_Internal_Error(v_headers);
                }else{
                  f_http_send(v_headers, 
                            m_http_response(
                                    m_http_response_ok(
                                            m_http_message_body_binary(
                                                    m_binary_body_ieee1609dot2_data(v_response_message)
                                            ), v_headers
                                    )));
                } 

                if( pf_test_pkiRequest != null) {
                  if( not pf_test_pkiRequest.apply( p_data, v_pki_request ) ) {
                    f_selfOrClientSyncAndVerdict(c_interSyncPoint, e_error);
                  }
                }
              }

              p_data.counter := p_data.counter + 1;