ItsDenm_TestCases.ttcn

                                        f_increaseSequenceNumber(
                                            v_actionIds[lengthof(v_actionIds)].sequenceNumber
                                        ),
                                        f_getIutStationId()
                                    ));
              f_utTerminateEvent(m_utEventCancellation(v_unknownActionId));
              
              tc_ac.start;
              alt {
                  [] denmPort.receive(
                      mw_denmInd(
                          mw_anyDenmPdu(
                              mw_itsPduHeader,
                              mw_denm (
                                  mw_denmMgmtCon(v_unknownActionId)
                              )
                          )
                      )
                  ) -> value v_denmInd {
                      tc_ac.stop;
                      log("*** " & testcasename() & ": FAIL: Received termination DENM for the unknown actionId. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      tc_ac.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] tc_ac.timeout {
                      log("*** " & testcasename() & ": PASS: No termination DENM was sent. ***");
                      f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                  }
              }
              
              // Postamble
              for (i := 0; i < lengthof(v_situations); i:=i + 1) {
                  f_poCancelEvent(e_iut, v_actionIds[i]);
              }
              f_cfDown();
             
          } // end TC_DEN_EVTR_BV_06
          
          /**
           * @desc    Check that DEN Basic Service does not send any termination DENM if actionID is not in 
           *          originator ITS-S message table or receiver ITS-S message table
           * <pre>        
           * PICS Selection: none 
           * Initial conditions:
           *  with {
           *      the IUT being in the "initial state"
           *      and the IUT having received several events
           *      and the IUT not having received event being associated with ACTION_ID1
           *          containing originatorStationID
           *              indicating STATION_ID1 different from its own stationID
           *          and containing sequenceNumber
           *              indicating SEQ1
           *  }
           * Expected behaviour:
           *  ensure that {
           *      when { 
           *          the IUT is requested to terminate an event associated to ACTION_ID1
           *              containing originatorStationID
           *                  indicating STATION_ID1
           *              and containing sequenceNumber
           *                  indicating SEQ1
           *      }
           *      then {
           *          the IUT does not send send any termination DENM for this event
           *      }
           *  }
           *  NOTE: Event associated to ACTION_ID1 cannot be present in originator ITS-S message table as its 
           *        stationID is not IUT’s stationID (see TP/DEN/EVTR/BV-06)
           * </pre>
           * 
           * @version 1.2.1
           * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/EVTR/BV-07, ETSI EN 302 637-3, clauses 8.1.2
           */
          testcase TC_DEN_EVTR_BV_07() runs on ItsDenm system ItsDenmSystem {
              
              // Local constants
              const SequenceNumber v_initialSequenceNumber := 0;
              // Local variables
              var template (value) SituationContainerList v_situations := {
                  m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable),
                  m_situation(c_causeAccident, c_subCauseCode_Unavailable),
                  m_situation(c_causeRoadworks, c_subCauseCode_Unavailable),
                  m_situation(c_causeSlowVehicle, c_subCauseCode_Unavailable)
              };
              var SequenceNumber v_sequenceNumber := v_initialSequenceNumber;
              var ActionID v_unknownActionId;
              var ActionIDList v_actionIds; 
              var DenmInd v_denmInd;
              var integer i;
              
              // Test control
              
              // Test component configuration
              f_cfUp();
              
              // Test adapter configuration
              
              // Preamble
              f_prInitialState();
              for (i := 0; i < lengthof(v_situations); i:=i + 1) {
                  v_sequenceNumber := f_increaseSequenceNumber(v_sequenceNumber);
                  v_actionIds[i] := f_sendDenMessage(
                      m_denm(
                          m_denmMgmtCon(
                              m_tsActionId(v_sequenceNumber)
                          ),
                          v_situations[i],
                          m_denmLocation_zeroDelta
                      )
                  );
              }
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
              
              // Test Body
              v_unknownActionId := valueof(m_actionId(
                                        f_increaseSequenceNumber(
                                            v_actionIds[lengthof(v_actionIds)].sequenceNumber
                                        ),
                                        f_getTsStationId()
                                    ));
              f_utTerminateEvent(m_utEventCancellation(v_unknownActionId));
              
              tc_ac.start;
              alt {
                  [] denmPort.receive(
                      mw_denmInd(
                          mw_anyDenmPdu(
                              mw_itsPduHeader,
                              mw_denm (
                                  mw_denmMgmtCon(v_unknownActionId)
                              )
                          )
                      )
                  ) -> value v_denmInd {
                      tc_ac.stop;
                      log("*** " & testcasename() & ": FAIL: Received termination DENM for the unknown actionId. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      tc_ac.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] tc_ac.timeout {
                      log("*** " & testcasename() & ": PASS: No termination DENM was sent. ***");
                      f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                  }
              }
              
              // Postamble
              for (i := 0; i < lengthof(v_situations); i:=i + 1) {
                  f_poCancelEvent(e_ets, v_actionIds[i]);
              }
              f_cfDown();
             
          } // end TC_DEN_EVTR_BV_07
          
      } // end denEventTermination
      
      // 5.2.1.5
      group denMessageRepetition {
          
          /**
           * @desc    Check that DEN Basic Service repeats DENM transmission according to transmissionInterval 
           *          parameter provided by application
           * <pre>        
           * PICS Selection: none 
           * Initial conditions:
           *  with {
           *      the IUT being in the "initial state"
           *      and the IUT having generated an event
           *          containing management container
           *              containing actionID
           *                  indicating ACTION_ID1
           *              and containing validityDuration
           *                  indicating DURATION_1
           *              and containing transmissionInterval
           *                  indicating INTERVAL_1
           *  }
           * Expected behaviour:
           *  ensure that {
           *      when { 
           *          the IUT is alerted of expiration of the time associated with INTERVAL_1
           *      }
           *      then {
           *          the IUT repeats the transmission of the valid DENM associated with ACTION_ID1
           *      }
           *  }
           * </pre>
           * 
           * @version 1.2.1
           * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/EVRP/BV-01, ETSI EN 302 637-3, clause 6.1.2.3
           */
          testcase TC_DEN_EVRP_BV_01() runs on ItsDenm system ItsDenmSystem {
              
              // Local constants
              const ValidityDuration c_validityDuration := c_validityDuration_10sec;
              const TransmissionInterval c_transmissionInterval := c_transmissionInterval_1sec;
              const float c_lowerTransmissionInterval := int2float(c_transmissionInterval)*0.95;
              const float c_upperTransmissionInterval := int2float(c_transmissionInterval)*1.05;
              const ValidityDuration c_repetitionDuration := c_validityDuration;
              // Local variables
              var template (value) SituationContainer v_situation := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
              var template (present) DenmInd v_expectedDenmInd := mw_denmInd(
                                                                      mw_denmPdu(
                                                                          mw_denm(
                                                                              mw_denmMgmtCon(
                                                                                  mw_actionId,
                                                                                  -,
                                                                                  -,
                                                                                  -,
                                                                                  c_validityDuration,
                                                                                  c_transmissionInterval
                                                                              )
                                                                          )
                                                                      )
                                                                  ); 
              var ActionID v_actionId;
              var DenmInd v_denmInd;
              // Local timers
              timer t_repetition;
              
              // Test control
              
              // Test component configuration
              f_cfUp();
              
              // Test adapter configuration
              
              // Preamble
              f_prInitialState();
              f_utTriggerEvent(
                  m_utTriggerEvent(
                      v_situation, 
                      m_denmLocation_zeroDelta,
                      c_validityDuration,
                      c_transmissionInterval,
                      c_repetitionDuration
                  )
              );
              f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              t_repetition.start(2.0 * int2float(c_transmissionInterval/1000));
              v_actionId := v_denmInd.msgIn.denm.management.actionID;
              v_expectedDenmInd.msgIn.denm.management.actionID := v_actionId;
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
              
              // Test Body
              alt {
                  [] denmPort.receive(v_expectedDenmInd) -> value v_denmInd {
                      if (match(t_repetition.read*1000.0, (c_lowerTransmissionInterval..c_upperTransmissionInterval))) {
                          t_repetition.stop;
                          log("*** " & testcasename() & ": PASS: Successfully received expected DENM in the expected interval. ***");
                          f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                      }
                      else {
                          t_repetition.stop;
                          log("*** " & testcasename() & ": FAIL: Received expected DENM, interval was not correct. ***");
                          f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                      }
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      t_repetition.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] t_repetition.timeout {
                      log("*** " & testcasename() & ": INCONC: Timeout while awaiting the reception of a message. ***");
                      f_selfOrClientSyncAndVerdict("error", e_timeout);
                  }
              }
              
              // Postamble
              f_poCancelEvent(e_iut, v_actionId);
              f_cfDown();
             
          } // end TC_DEN_EVRP_BV_01
          
          /**
           * @desc    Check that the repeated DENM is always the most up-to-date message
           * <pre>        
           * PICS Selection: none 
           * Initial conditions:
           *  with {
           *      the IUT being in the "initial state"
           *      and the IUT having generated an event
           *          containing management container
           *              containing actionID
           *                  indicating ACTION_ID1
           *              and containing validityDuration
           *                  indicating DURATION_1
           *              and containing transmissionInterval
           *                  indicating INTERVAL_1
           *      and the IUT having generated an update of the event associated with ACTION_ID1 modifying partly the event
           *  }
           * Expected behaviour:
           *  ensure that {
           *      when { 
           *          the IUT is alerted of expiration of the time associated with INTERVAL_1
           *      }
           *      then {
           *          the IUT repeats the transmission of the valid DENM associated with ACTION_ID1
           *      }
           *  }
           * </pre>
           * 
           * @version 1.2.1
           * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/EVRP/BV-02, ETSI EN 302 637-3, clause 6.1.2.3
           */
          testcase TC_DEN_EVRP_BV_02() runs on ItsDenm system ItsDenmSystem {
              
              // Local constants
              const ValidityDuration c_validityDuration := c_validityDuration_10sec;
              const TransmissionInterval c_transmissionInterval := c_transmissionInterval_5sec;
              const ValidityDuration c_repetitionDuration := c_validityDuration;
              const float c_lowerTransmissionInterval := int2float(c_transmissionInterval)*0.95;
              const float c_upperTransmissionInterval := int2float(c_transmissionInterval)*1.05;
              // Local variables
              var template (value) SituationContainer v_situation := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
              var template (present) DenmInd v_expectedDenmInd := mw_denmInd(
                                                                      mw_denmPdu(
                                                                          mw_denm(
                                                                              mw_denmMgmtCon(
                                                                                  mw_actionId,
                                                                                  -,
                                                                                  -,
                                                                                  -,
                                                                                  c_validityDuration,
                                                                                  c_transmissionInterval
                                                                              )
                                                                          )
                                                                      )
                                                                  ); 
              var ActionID v_actionId;
              var DenmInd v_denmInd;
              // Local timers
              timer t_repetition;
              
              // Test control
              
              // Test component configuration
              f_cfUp();
              
              // Test adapter configuration
              
              // Preamble
              f_prInitialState();
              f_utTriggerEvent(
                  m_utTriggerEvent(
                      v_situation, 
                      m_denmLocation_zeroDelta, 
                      c_validityDuration, 
                      c_transmissionInterval,
                      c_repetitionDuration
                  )
              );
              f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              v_actionId := v_denmInd.msgIn.denm.management.actionID;
              v_expectedDenmInd.msgIn.denm.management.actionID := v_actionId;
              //update event after 1 second
              tc_noac.start(1.0);
              tc_noac.timeout;
              v_situation.eventType.subCauseCode := c_vehicleBreakDownSubCauseCode_engineProblem;
              f_utUpdateEvent(m_utUpdateEvent(v_actionId, v_situation));
              v_expectedDenmInd.msgIn.denm.situation := v_situation;
              f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              t_repetition.start(2.0 * int2float(c_transmissionInterval/1000));
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
              
              // Test Body
              alt {
                  [] denmPort.receive(v_expectedDenmInd) -> value v_denmInd {
                      if (match(t_repetition.read*1000.0, (c_lowerTransmissionInterval..c_upperTransmissionInterval))) {
                          t_repetition.stop;
                          log("*** " & testcasename() & ": PASS: Successfully received expected DENM in the expected interval. ***");
                          f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_success);
                      }
                      else {
                          t_repetition.stop;
                          log("*** " & testcasename() & ": FAIL: Received expected DENM, interval was not correct. ***");
                          f_selfOrClientSyncAndVerdictTestBody(c_tbDone, e_error);
                      }
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      t_repetition.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] t_repetition.timeout {
                      log("*** " & testcasename() & ": INCONC: Timeout while awaiting the reception of a message. ***");
                      f_selfOrClientSyncAndVerdict("error", e_timeout);
                  }
              }
              
              // Postamble
              f_poCancelEvent(e_iut, v_actionId);
              f_cfDown();
             
          } // end TC_DEN_EVRP_BV_02
          
          /**
           * @desc    Check that DEN Basic Service stops retransmitting DENM after event’s validityDuration 
           *          expiration
           * <pre>        
           * PICS Selection: none 
           * Initial conditions:
           *  with {
           *      the IUT being in the "initial state"
           *      and the IUT having generated an event
           *          containing management container
           *              containing actionID
           *                  indicating ACTION_ID1
           *              and containing validityDuration
           *                  indicating DURATION_1
           *              and containing transmissionInterval
           *                  indicating INTERVAL_1
           *      and the IUT having repeated (one or more) the transmission of the valid DENM associated with ACTION_ID1
           *  }
           * Expected behaviour:
           *  ensure that {
           *      when { 
           *          the IUT is alerted of expiration of the time associated with DURATION_1
           *      }
           *      then {
           *          the IUT stops the retransmission of the most up-to-date valid DENM associated with ACTION_ID1
           *      }
           *  }
           * </pre>
           * 
           * @version 1.2.1
           * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/EVRP/BV-03, ETSI EN 302 637-3, clauses 6.1.2.4, 8.1.2
           */
          testcase TC_DEN_EVRP_BV_03() runs on ItsDenm system ItsDenmSystem {
              
              // Local constants
              const ValidityDuration c_validityDuration := c_validityDuration_10sec;
              const TransmissionInterval c_transmissionInterval := c_transmissionInterval_4sec;
              const ValidityDuration c_repetitionDuration := c_validityDuration;
              // Local variables
              var template (value) SituationContainer v_situation := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
              var template (present) DenmInd v_expectedDenmInd := mw_denmInd(
                                                                      mw_denmPdu(
                                                                          mw_denm(
                                                                              mw_denmMgmtCon(
                                                                                  mw_actionId,
                                                                                  -,
                                                                                  -,
                                                                                  -,
                                                                                  c_validityDuration,
                                                                                  c_transmissionInterval
                                                                              )
                                                                          )
                                                                      )
                                                                  ); 
              var ActionID v_actionId;
              var DenmInd v_denmInd;
              var integer i;
              // Local timers
              timer t_validity;
              
              // Test control
              
              // Test component configuration
              f_cfUp();
              
              // Test adapter configuration
              
              // Preamble
              f_prInitialState();
              f_utTriggerEvent(
                  m_utTriggerEvent(
                      v_situation, 
                      m_denmLocation_zeroDelta, 
                      c_validityDuration, 
                      c_transmissionInterval,
                      c_repetitionDuration
                  )
              );
              f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              t_validity.start(1.5 * int2float(c_validityDuration));
              v_actionId := v_denmInd.msgIn.denm.management.actionID;
              v_expectedDenmInd.msgIn.denm.management.actionID := v_actionId;
              //await retransmitted DENM message based on the transmission interval in between the validity duration
              for (i:=0; i<(c_validityDuration/(c_transmissionInterval/1000)); i:=i+1) {
                  f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              }
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
              
              // Test Body
              alt {
                  [] t_validity.timeout {
                      log("*** " & testcasename() & ": PASS: Retransmission of DENM stopped successfully. ***");
                      f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                  }
                  [] denmPort.receive(v_expectedDenmInd) -> value v_denmInd {
                      t_validity.stop;
                      log("*** " & testcasename() & ": FAIL: Retransmission of DENM was not stopped. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      t_validity.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
              }
              
              // Postamble
              f_poCancelEvent(e_iut, v_actionId);
              f_cfDown();
             
          } // end TC_DEN_EVRP_BV_03
          
          /**
           * @desc    Check that DEN Basic Service stops retransmitting DENM after event’s repetitionDuration 
           *          expiration
           * <pre>        
           * PICS Selection: none 
           * Initial conditions:
           *  with {
           *      the IUT being in the "initial state"
           *      and the IUT having received an AppDENM_trigger request from application layer
           *          containing repetitionDuration
           *              indicating DURATION_2
           *      and the IUT having generated an event
           *          containing management container
           *              containing actionID
           *                  indicating ACTION_ID1
           *              and containing validityDuration
           *                  indicating DURATION_1 > DURATION_2
           *              and containing transmissionInterval
           *                  indicating INTERVAL_1
           *      and the IUT having repeated (one or more) the transmission of the valid DENM associated with ACTION_ID1
           *  }
           * Expected behaviour:
           *  ensure that {
           *      when { 
           *          the IUT is alerted of expiration of the time associated with DURATION_2
           *      }
           *      then {
           *          the IUT stops the retransmission of the most up-to-date valid DENM associated with ACTION_ID1
           *      }
           *  }
           * </pre>
           * 
           * @version 1.2.1
           * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/EVRP/BV-04, ETSI EN 302 637-3, clause 8.1.2
           */
          testcase TC_DEN_EVRP_BV_04() runs on ItsDenm system ItsDenmSystem {
              
              // Local constants
              const ValidityDuration c_validityDuration := c_validityDuration_10sec;
              const TransmissionInterval c_transmissionInterval := c_transmissionInterval_2sec;
              const ValidityDuration c_repetitionDuration := c_repetitionDuration_5sec;
              // Local variables
              var template (value) SituationContainer v_situation := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
              var template (present) DenmInd v_expectedDenmInd := mw_denmInd(
                                                                      mw_denmPdu(
                                                                          mw_denm(
                                                                              mw_denmMgmtCon(
                                                                                  mw_actionId,
                                                                                  -,
                                                                                  -,
                                                                                  -,
                                                                                  c_validityDuration,
                                                                                  c_transmissionInterval
                                                                              )
                                                                          )
                                                                      )
                                                                  ); 
              var ActionID v_actionId;
              var DenmInd v_denmInd;
              var integer i;
              // Local timers
              timer t_repetition;
              
              // Test control
              
              // Test component configuration
              f_cfUp();
              
              // Test adapter configuration
              
              // Preamble
              f_prInitialState();
              f_utTriggerEvent(
                  m_utTriggerEvent(
                      v_situation, 
                      m_denmLocation_zeroDelta, 
                      c_validityDuration, 
                      c_transmissionInterval,
                      c_repetitionDuration
                  )
              );
              f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              t_repetition.start(1.5 * int2float(c_repetitionDuration));
              v_actionId := v_denmInd.msgIn.denm.management.actionID;
              v_expectedDenmInd.msgIn.denm.management.actionID := v_actionId;
              //await retransmitted DENM message based on the transmission interval in between the repetition duration
              for (i:=0; i<(c_repetitionDuration/(c_transmissionInterval/1000)); i:=i+1) {
                  f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              }
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
              
              // Test Body
              alt {
                  [] t_repetition.timeout {
                      log("*** " & testcasename() & ": PASS: Retransmission of DENM stopped successfully. ***");
                      f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                  }
                  [] denmPort.receive(v_expectedDenmInd) -> value v_denmInd {
                      t_repetition.stop;
                      log("*** " & testcasename() & ": FAIL: Retransmission of DENM was not stopped. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      t_repetition.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
              }
              
              // Postamble
              f_poCancelEvent(e_iut, v_actionId);
              f_cfDown();
             
          } // end TC_DEN_EVRP_BV_04
          
          /**
           * @desc    Check that DEN Basic Service does not repeat transmission of DENM if transmissionInterval is 
           *          not provided by application
           * <pre>        
           * PICS Selection: none 
           * Initial conditions:
           *  with {
           *      the IUT being in the "initial state"
           *      and the IUT having received an AppDENM_trigger request from application layer
           *          not containing transmissionInterval
           *      and the IUT having generated an event
           *          containing management container
           *              containing actionID
           *                  indicating ACTION_ID1
           *              and containing validityDuration
           *                  indicating DURATION_1
           *  }
           * Expected behaviour:
           *  ensure that {
           *      when { 
           *          the IUT has detected that transmissionInterval is not provided for the event associated with ACTION_ID1
           *      }
           *      then {
           *          the IUT does not repeat the transmission of the valid DENM associated with ACTION_ID1
           *      }
           *  }
           * </pre>
           * 
           * @version 1.2.1
           * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/EVRP/BV-05, ETSI EN 302 637-3, clause 8.1.2
           */
          testcase TC_DEN_EVRP_BV_05() runs on ItsDenm system ItsDenmSystem {
              
              // Local constants
              const ValidityDuration c_validityDuration := c_validityDuration_10sec;
              const ValidityDuration c_repetitionDuration := c_validityDuration;
              // Local variables
              var template (value) SituationContainer v_situation := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
              var template (present) DenmInd v_expectedDenmInd := mw_denmInd(
                                                                      mw_denmPdu(
                                                                          mw_denm(
                                                                              mw_denmMgmtCon(
                                                                                  mw_actionId,
                                                                                  -,
                                                                                  -,
                                                                                  -,
                                                                                  c_validityDuration
                                                                              )
                                                                          )
                                                                      )
                                                                  ); 
              var ActionID v_actionId;
              var DenmInd v_denmInd;
              var integer i;
              // Local timers
              timer t_validity;
              
              // Test control
              
              // Test component configuration
              f_cfUp();
              
              // Test adapter configuration
              
              // Preamble
              f_prInitialState();
              f_utTriggerEvent(
                  m_utTriggerEvent(
                      v_situation, 
                      m_denmLocation_zeroDelta, 
                      c_validityDuration, 
                      omit, //no transmissionInterval
                      c_repetitionDuration
                  )
              );
              f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              t_validity.start(1.5 * int2float(c_validityDuration));
              v_actionId := v_denmInd.msgIn.denm.management.actionID;
              v_expectedDenmInd.msgIn.denm.management.actionID := v_actionId;
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
              
              // Test Body
              alt {
                  [] t_validity.timeout {
                      log("*** " & testcasename() & ": PASS: No retransmission of DENM occured as expected. ***");
                      f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                  }
                  [] denmPort.receive(v_expectedDenmInd) -> value v_denmInd {
                      t_validity.stop;
                      log("*** " & testcasename() & ": FAIL: Unexpected retransmission of DENM occured. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      t_validity.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
              }
              
              // Postamble
              f_poCancelEvent(e_iut, v_actionId);
              f_cfDown();
             
          } // end TC_DEN_EVRP_BV_05
          
          /**
           * @desc    Check that DEN Basic Service does not repeat transmission of DENM if repetitionDuration is 
           *          not provided by application
           * <pre>        
           * PICS Selection: none 
           * Initial conditions:
           *  with {
           *      the IUT being in the "initial state"
           *      and the IUT having received an AppDENM_trigger request from application layer
           *          not containing repetitionDuration
           *      and the IUT having generated an event
           *          containing management container
           *              containing actionID
           *                  indicating ACTION_ID1
           *              and containing validityDuration
           *                  indicating DURATION_1
           *              and containing transmissionInterval
           *                  indicating INTERVAL_1
           *  }
           * Expected behaviour:
           *  ensure that {
           *      when { 
           *          the IUT has detected that repetitionDuration is not provided for the event associated with ACTION_ID1
           *      }
           *      then {
           *          the IUT does not repeat the transmission of the valid DENM associated with ACTION_ID1
           *      }
           *  }
           * </pre>
           * 
           * @version 1.2.1
           * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/EVRP/BV-06, ETSI EN 302 637-3, clause 6.1.2.3
           */
          testcase TC_DEN_EVRP_BV_06() runs on ItsDenm system ItsDenmSystem {
              
              // Local constants
              const ValidityDuration c_validityDuration := c_validityDuration_10sec;
              const TransmissionInterval c_transmissionInterval := c_transmissionInterval_2sec;
              // Local variables
              var template (value) SituationContainer v_situation := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
              var template (present) DenmInd v_expectedDenmInd := mw_denmInd(
                                                                      mw_denmPdu(
                                                                          mw_denm(
                                                                              mw_denmMgmtCon(
                                                                                  mw_actionId,
                                                                                  -,
                                                                                  -,
                                                                                  -,
                                                                                  c_validityDuration,
                                                                                  c_transmissionInterval
                                                                              )
                                                                          )
                                                                      )
                                                                  ); 
              var ActionID v_actionId;
              var DenmInd v_denmInd;
              var integer i;
              // Local timers
              timer t_validity;
              
              // Test control
              
              // Test component configuration
              f_cfUp();
              
              // Test adapter configuration
              
              // Preamble
              f_prInitialState();
              f_utTriggerEvent(
                  m_utTriggerEvent(
                      v_situation, 
                      m_denmLocation_zeroDelta, 
                      c_validityDuration, 
                      c_transmissionInterval,
                      omit //no repetitionDuration
                  )
              );
              f_awaitDenMessage(v_expectedDenmInd, v_denmInd);
              t_validity.start(1.5 * int2float(c_validityDuration));
              v_actionId := v_denmInd.msgIn.denm.management.actionID;
              v_expectedDenmInd.msgIn.denm.management.actionID := v_actionId;
              f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
              
              // Test Body
              alt {
                  [] t_validity.timeout {
                      log("*** " & testcasename() & ": PASS: No retransmission of DENM occured as expected. ***");
                      f_selfOrClientSyncAndVerdict(c_tbDone, e_success);
                  }
                  [] denmPort.receive(v_expectedDenmInd) -> value v_denmInd {
                      t_validity.stop;
                      log("*** " & testcasename() & ": FAIL: Unexpected retransmission of DENM occured. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
                  [] denmPort.receive(mw_denmInd(mw_anyDenmPdu)) {
                      t_validity.stop;
                      log("*** " & testcasename() & ": FAIL: Received an unexpected DENM. ***");
                      f_selfOrClientSyncAndVerdict("error", e_error);
                  }
              }
              
              // Postamble
              f_poCancelEvent(e_iut, v_actionId);
              f_cfDown();
             
          } // end TC_DEN_EVRP_BV_06
          
      } // end denMessageRepetition
      
    } // end denMessageTransmission
    
    // 5.2.2
    group denMessageReception {
        
        /**
         * @desc    Check that receiver ITS-S transmits DENM to application if it concerns an unknown ActionID 
         *          and if it is not a termination DENM
         * <pre>
         * PICS Selection: none
         * Initial conditions:
         *  with {
         *      the IUT being in the "initial state"
         *      and the IUT not having send DENM
         *          containing management container
         *              containing actionID
         *                  indicating ACTION_ID1
         *      and the IUT not having received DENM
         *          containing management container
         *              containing actionID
         *                  indicating ACTION_ID1
         *  }
         * Expected behaviour:
         *  ensure that {
         *      when { 
         *          the IUT receives a DENM that is not a termination
         *              containing management container
         *                  containing actionID
         *                      indicating ACTION_ID1
         *      }
         *      then {
         *          the IUT transmits the DENM content to upper layer
         *      }
         *  }
         * </pre>
         * 
         * @version 1.2.1
         * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/MSRV/BV-01, ETSI EN 302 637-3, clause 8.3.2
         */
        testcase TC_DEN_MSRV_BV_01() runs on ItsDenm system ItsDenmSystem {
            
            // Local variables
            var template (value) SituationContainer v_situation := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
            var ActionID v_actionId;
            var integer i;
            
            // Test control
            
            // Test component configuration
            f_cfUp();
            
            // Test adapter configuration
            
            // Preamble
            f_prInitialState();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Test Body
            v_actionId := f_sendDenMessage(
                m_denm(
                    m_denmMgmtCon(
                        m_tsActionId
                    ),
                    v_situation,
                    m_denmLocation_zeroDelta
                )
            );
            
            f_sleep(PX_TAC);
            for(i:=0; i < lengthof(vc_utEvents) and not match(v_actionId, vc_utEvents[i].denMsg.denm.management.actionID); i:=i+1) {
                // empty on purpose 
            }
            if(i < lengthof(vc_utEvents)) {
                log("*** " & testcasename() & ": PASS: DENM was transmitted to upper layer ***");
                f_clientSyncAndVerdict(c_tbDone, e_success);
            }
            else {
                log("*** " & testcasename() & ": FAIL: DENM was not transmitted to upper layer ***");
                f_clientSyncAndVerdict(c_tbDone, e_error);
            }
            
            // Postamble
            f_poCancelEvent(e_ets, v_actionId);
            f_cfDown();
            
        } // end TC_DEN_MSRV_BV_01
        
        /**
         * @desc    Check that receiver ITS-S transmits DENM to application if it concerns a known ActionID 
         *          and referenceTime is greater than highest value received for this ActionID
         * <pre>
         * PICS Selection: none
         * Initial conditions:
         *  with {
         *      the IUT being in the "initial state"
         *      and the IUT having received DENM
         *          containing management container
         *              containing actionID
         *                  indicating ACTION_ID1
         *              and containing referenceTime
         *                  indicating  REFERENCETIME_1
         *  }
         * Expected behaviour:
         *  ensure that {
         *      when { 
         *          the IUT receives a DENM
         *              containing management container
         *                  containing actionID
         *                      indicating ACTION_ID1
         *                  and containing referenceTime
         *                      indicating REFERENCETIME_2 greater than REFERENCETIME_1

         *      }
         *      then {
         *          the IUT transmits the DENM content to upper layer
         *      }
         *  }
         * </pre>
         * 
         * @version 1.2.1
         * @see     ETSI TS 102 869-2 v1.2.1 TP/DEN/MSRV/BV-02, ETSI EN 302 637-3, clause 8.3.2
         */
        testcase TC_DEN_MSRV_BV_02() runs on ItsDenm system ItsDenmSystem {
            
            // Local variables
            var template (value) SituationContainer v_situation1 := m_situation(c_causeVehicleBreakdown, c_subCauseCode_Unavailable);
            var template (value) SituationContainer v_situation2 := m_situation(c_causeVehicleBreakdown, c_vehicleBreakDownSubCauseCode_engineProblem);
            var TimestampIts v_referenceTime2;
            var ActionID v_actionId;
            var integer i;
            
            // Test control
            
            // Test component configuration
            f_cfUp();
            
            // Test adapter configuration
            
            // Preamble
            f_prInitialState();
            f_selfOrClientSyncAndVerdictPreamble(c_prDone, e_success);
            
            // Test Body
            v_actionId := f_sendDenMessage(
                m_denm(
                    m_denmMgmtCon(
                        m_tsActionId
                    ),
                    v_situation1,
                    m_denmLocation_zeroDelta
                )
            );
            
            f_sleep(1.0);
            v_referenceTime2 := f_getCurrentTime();