Commit 98b9cd50 authored by Yann Garcia's avatar Yann Garcia
Browse files

Validate VRU Test System

parent 39efe1c9

ccsrc/Ports/LibIts_ports/RSUsSimulator_ports/ConfigRsuSimulatorLayer.cc

+89 −0
Original line number Original line Diff line number Diff line
@@ -450,6 +450,9 @@ void ConfigRsuSimulatorLayer::sendMsg(const LibItsVru__TypesAndValues::UtVamResu 
  if (send_par.ischosen(LibItsVru__TypesAndValues::UtVamResults::ALT_utVamInitializeResult)) {

  if (send_par.ischosen(LibItsVru__TypesAndValues::UtVamResults::ALT_utVamInitializeResult)) {

    encoding_buffer.put_c(static_cast<const uint8_t>(uppertester_vru_codec::c_utVamInitializeResult));

    encoding_buffer.put_c(static_cast<const uint8_t>(uppertester_vru_codec::c_utVamInitializeResult));

    encoding_buffer.put_c((uint8_t)static_cast<const boolean>(send_par.utVamInitializeResult()));

    encoding_buffer.put_c((uint8_t)static_cast<const boolean>(send_par.utVamInitializeResult()));

  } else if (send_par.ischosen(LibItsVru__TypesAndValues::UtVamResults::ALT_utVamTriggerResult)) {

    encoding_buffer.put_c(static_cast<const uint8_t>(uppertester_vru_codec::c_utVamTriggerResult));

    encoding_buffer.put_c((uint8_t)static_cast<const boolean>(send_par.utVamTriggerResult()));

  } else {

  } else {

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::sendMsg: Unsupported UtVamResults variant");

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::sendMsg: Unsupported UtVamResults variant");

    return;

    return;
@@ -529,6 +532,10 @@ void ConfigRsuSimulatorLayer::receive_data(OCTETSTRING &data, params &params) { 
  } else if ((id == uppertester_pki_codec::c_utPkiTriggerEnrolmentRequest) ||

  } else if ((id == uppertester_pki_codec::c_utPkiTriggerEnrolmentRequest) ||

             (id == uppertester_pki_codec::c_utPkiTriggerAuthorizationRequest)) { // Receive an UtPkiTrigger

             (id == uppertester_pki_codec::c_utPkiTriggerAuthorizationRequest)) { // Receive an UtPkiTrigger

    process_ut_pki_trigger(data, params);

    process_ut_pki_trigger(data, params);

  } else if (id == uppertester_vru_codec::c_utVamTrigger) { // Receive an UtMbrTrigger

    process_ut_vam_trigger(data, params);

  // } else if (id == uppertester_cps_codec::c_utCpmTrigger) { // Receive an UtMbrTrigger

  //   process_ut_cpm_trigger(data, params);

  } else if (id == uppertester_mbr_codec::c_utMbrTrigger) { // Receive an UtMbrTrigger

  } else if (id == uppertester_mbr_codec::c_utMbrTrigger) { // Receive an UtMbrTrigger

    process_ut_mbr_trigger(data, params);

    process_ut_mbr_trigger(data, params);

  } else {

  } else {
@@ -590,6 +597,16 @@ int ConfigRsuSimulatorLayer::process_utinitialize_data(const OCTETSTRING &data, 
    LibItsMbr__TypesAndValues::UtMbrInitialize p(hashedId);

    LibItsMbr__TypesAndValues::UtMbrInitialize p(hashedId);

    // Pass it to the ports if any

    // Pass it to the ports if any

    to_all_upper_ports(p, params);

    to_all_upper_ports(p, params);

  } else if (_params[std::string("ut")].compare("vam") == 0) {

    OCTETSTRING                                      hashedId(data.lengthof() - 1, 1 + static_cast<const uint8_t *>(data));

    LibItsVru__TypesAndValues::UtVamInitialize p(hashedId);

    // Pass it to the ports if any

    to_all_upper_ports(p, params);

  } else if (_params[std::string("ut")].compare("cpm") == 0) {

    OCTETSTRING                                      hashedId(data.lengthof() - 1, 1 + static_cast<const uint8_t *>(data));

    LibItsCps__TypesAndValues::UtCpmInitialize p(hashedId);

    // Pass it to the ports if any

    to_all_upper_ports(p, params);

  } else {

  } else {

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::process_utinitialize_data: Unsupported protocol");

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::process_utinitialize_data: Unsupported protocol");

    return -1;

    return -1;
@@ -1582,6 +1599,78 @@ int ConfigRsuSimulatorLayer::process_ut_rtcmem_termination(const OCTETSTRING &da 
  return 0;

  return 0;

}

}





int ConfigRsuSimulatorLayer::process_ut_vam_trigger(const OCTETSTRING &data, params &params) {

  loggers::get_instance().log_msg(">>> ConfigRsuSimulatorLayer::process_ut_vam_trigger", data);



  params::const_iterator it = _params.find("ut");

  if (it == _params.cend()) {

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::process_ut_vam_trigger: CF layer's ut parameter is missing");

    return -1;

  }



  if (_params[std::string("ut")].compare("vam") == 0) {

    uint8_t *p      = (uint8_t *)static_cast<const uint8_t *>(data);

    uint8_t  msg_id = *p++;

    loggers::get_instance().log("ConfigRsuSimulatorLayer::process_ut_vam_trigger: msg_id=%02x", msg_id);

    uint8_t flag = *p++;

    loggers::get_instance().log("ConfigRsuSimulatorLayer::process_ut_vam_trigger: flag=%02x", flag);

    LibItsVru__TypesAndValues::UtVamTrigger trigger;

    // Decode msgs

    if ((flag & 0x80) == 0x80) {

      trigger.setVruProfile() = *p;

    }

    if ((flag & 0x40) == 0x40) {

      trigger.leaveClusterWithCause() = *p;

    }

    loggers::get_instance().log_msg("ConfigRsuSimulatorLayer::process_ut_vam_trigger: ", trigger);



    // Pass it to the ports if any

    to_all_upper_ports(trigger, params);

  } else {

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::process_ut_vam_trigger: Unsupported protocol");

    return -1;

  }



  return 0;

}



int ConfigRsuSimulatorLayer::process_ut_cpm_trigger(const OCTETSTRING &data, params &params) {

  loggers::get_instance().log_msg(">>> ConfigRsuSimulatorLayer::process_ut_cpm_trigger", data);



  params::const_iterator it = _params.find("ut");

  if (it == _params.cend()) {

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::process_ut_cpm_trigger: CF layer's ut parameter is missing");

    return -1;

  }



  if (_params[std::string("ut")].compare("cpm") == 0) {

    uint8_t *p      = (uint8_t *)static_cast<const uint8_t *>(data);

    uint8_t  msg_id = *p++;

    loggers::get_instance().log("ConfigRsuSimulatorLayer::process_ut_cpm_trigger: msg_id=%02x", msg_id);

    uint8_t flag = *p++;

    loggers::get_instance().log("ConfigRsuSimulatorLayer::process_ut_cpm_trigger: flag=%02x", flag);

    // LibItsCps__TypesAndValues::UtCpmTrigger trigger;

    // // Decode msgs

    // if ((flag & 0x80) == 0x80) {

    //   trigger.setVruProfile() = *p;

    // }

    // if ((flag & 0x40) == 0x40) {

    //   trigger.leaveClusterWithCause() = *p;

    // }

    // loggers::get_instance().log_msg("ConfigRsuSimulatorLayer::process_ut_cpm_trigger: ", trigger);



    // // Pass it to the ports if any

    // to_all_upper_ports(trigger, params);

  } else {

    loggers::get_instance().warning("ConfigRsuSimulatorLayer::process_ut_cpm_trigger: Unsupported protocol");

    return -1;

  }



  return 0;

}







int ConfigRsuSimulatorLayer::set_cause_code_choice(const int p_cause, ETSI__ITS__CDD::CauseCodeChoice& p_causeCodeChoice) {

int ConfigRsuSimulatorLayer::set_cause_code_choice(const int p_cause, ETSI__ITS__CDD::CauseCodeChoice& p_causeCodeChoice) {

  loggers::get_instance().log(">>> ConfigRsuSimulatorLayer::set_cause_code_choice: %d", p_cause);

  loggers::get_instance().log(">>> ConfigRsuSimulatorLayer::set_cause_code_choice: %d", p_cause);

ccsrc/Ports/LibIts_ports/RSUsSimulator_ports/ConfigRsuSimulatorLayer.hh

+3 −0
Original line number Original line Diff line number Diff line
@@ -96,5 +96,8 @@ private: 
  int process_ut_rtcmem_trigger(const OCTETSTRING &data, params &params);

  int process_ut_rtcmem_trigger(const OCTETSTRING &data, params &params);

  int process_ut_rtcmem_update(const OCTETSTRING &data, params &params);

  int process_ut_rtcmem_update(const OCTETSTRING &data, params &params);

  int process_ut_rtcmem_termination(const OCTETSTRING &data, params &params);

  int process_ut_rtcmem_termination(const OCTETSTRING &data, params &params);

  int process_ut_vam_trigger(const OCTETSTRING &data, params &params);

  int process_ut_cpm_trigger(const OCTETSTRING &data, params &params);



  int set_cause_code_choice(const int p_cause, ETSI__ITS__CDD::CauseCodeChoice& p_causeCodeChoice);

  int set_cause_code_choice(const int p_cause, ETSI__ITS__CDD::CauseCodeChoice& p_causeCodeChoice);

}; // End of class ConfigRsuSimulatorLayer
 
}; // End of class ConfigRsuSimulatorLayer

ccsrc/Ports/LibIts_ports/RSUsSimulator_ports/ConfigRsuSimulatorPort.cc

+10 −0
Original line number Original line Diff line number Diff line
@@ -611,4 +611,14 @@ namespace ItsRSUsSimulator__TestSystem { 
    incoming_message(p_ind);

    incoming_message(p_ind);

  }

  }





  void ConfigRsuSimulatorPort::receiveMsg(const LibItsVru__TypesAndValues::UtVamTrigger &p_ind, const params &p_params) {

    loggers::get_instance().log_msg(">>> ConfigRsuSimulatorPort::receive_msg: ", p_ind);

    // Sanity check

    if (!p_ind.is_bound()) {

      return;

    }



    incoming_message(p_ind);

  }



} // namespace ItsRSUsSimulator__TestSystem
 
} // namespace ItsRSUsSimulator__TestSystem

ccsrc/Ports/LibIts_ports/RSUsSimulator_ports/ConfigRsuSimulatorPort.hh

+2 −0
Original line number Original line Diff line number Diff line
@@ -48,7 +48,9 @@ namespace ItsRSUsSimulator__TestSystem { 
    void receiveMsg(const LibItsRtcmem__TypesAndValues::UtRtcmemUpdate &p_ind, const params &p_params);

    void receiveMsg(const LibItsRtcmem__TypesAndValues::UtRtcmemUpdate &p_ind, const params &p_params);

    void receiveMsg(const LibItsRtcmem__TypesAndValues::UtRtcmemTermination &p_ind, const params &p_params);

    void receiveMsg(const LibItsRtcmem__TypesAndValues::UtRtcmemTermination &p_ind, const params &p_params);

    void receiveMsg(const LibItsCps__TypesAndValues::UtCpmInitialize &p_ind, const params &p_params);

    void receiveMsg(const LibItsCps__TypesAndValues::UtCpmInitialize &p_ind, const params &p_params);

    //void receiveMsg(const LibItsCps__TypesAndValues::UtCpmTrigger &p_ind, const params &p_params);

    void receiveMsg(const LibItsVru__TypesAndValues::UtVamInitialize &p_ind, const params &p_params);

    void receiveMsg(const LibItsVru__TypesAndValues::UtVamInitialize &p_ind, const params &p_params);

    void receiveMsg(const LibItsVru__TypesAndValues::UtVamTrigger &p_ind, const params &p_params);





    /*void send(const CfInitialize& send_par, const COMPONENT& destination_component);

    /*void send(const CfInitialize& send_par, const COMPONENT& destination_component);

    void send(const CfInitialize& send_par);

    void send(const CfInitialize& send_par);

ccsrc/Protocols/UpperTester/uppertester_vru_codec.cc

+36 −46
Original line number Original line Diff line number Diff line
@@ -13,56 +13,47 @@ class TTCN_EncDec; 




uint8_t uppertester_vru_codec::c_utVamInitialize       = 0x00;

uint8_t uppertester_vru_codec::c_utVamInitialize       = 0x00;

uint8_t uppertester_vru_codec::c_utVamInitializeResult = 0x01;

uint8_t uppertester_vru_codec::c_utVamInitializeResult = 0x01;

uint8_t uppertester_vru_codec::c_utVamSetProfile       = 0x20;

uint8_t uppertester_vru_codec::c_utVamTrigger          = 0xF3;

uint8_t uppertester_vru_codec::c_utVamEventInd         = 0x23;

uint8_t uppertester_vru_codec::c_utVamTriggerResult    = 0xF4;

uint8_t uppertester_vru_codec::c_utVamEventInd         = 0xF5;





int uppertester_vru_codec::encode(const Record_Type &msg, OCTETSTRING &data) {

int uppertester_vru_codec::encode(const LibItsVru__TypesAndValues::UtVamInitialize &r, OCTETSTRING &data) {

  loggers::get_instance().log_msg(">>> uppertester_vru_codec::encode: ", (const Record_Type &)msg);

  loggers::get_instance().log_msg(">>> uppertester_vru_codec::encode (1): ", r);





  TTCN_EncDec::clear_error();

  TTCN_EncDec::clear_error();

  TTCN_Buffer encoding_buffer;

  TTCN_Buffer encoding_buffer;

  if (std::string(msg.get_descriptor()->name).compare("@LibItsVru_TypesAndValues.UtVamInitialize") == 0) {

  encoding_buffer.put_c(static_cast<const uint8_t>(uppertester_vru_codec::c_utVamInitialize));

  encoding_buffer.put_c(static_cast<const uint8_t>(uppertester_vru_codec::c_utVamInitialize));

  } else { // Error

  encoding_buffer.put_string(r.hashedId8());

    data = OCTETSTRING(0, nullptr);

    loggers::get_instance().warning("<<< uppertester_vru_codec::encode: Failed to encode UT message");

    return -1;

  }

  encode_(msg, *msg.get_descriptor(), encoding_buffer);

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());

  loggers::get_instance().log_msg("<<< uppertester_vru_codec::encode: data=", data);

  loggers::get_instance().log_msg("<<< uppertester_vru_codec::encode (1): data=", data);

  return 0;

  return 0;

}

}





int uppertester_vru_codec::encode_(const Base_Type &type, const TTCN_Typedescriptor_t &field_descriptor, TTCN_Buffer &encoding_buffer) {

int uppertester_vru_codec::encode(const LibItsVru__TypesAndValues::UtVamTrigger &r, OCTETSTRING &data) {

  loggers::get_instance().log(">>> uppertester_vru_codec::encode_: processing %s/%s/%p", type.get_descriptor()->name, field_descriptor.name,

  loggers::get_instance().log_msg(">>> uppertester_vru_codec::encode (2): ", r);

                              dynamic_cast<const Record_Type *>(&type));



  loggers::get_instance().log_msg(">>> uppertester_vru_codec::encode_: ", type);

  TTCN_EncDec::clear_error();



  TTCN_Buffer encoding_buffer;

  if (dynamic_cast<const Record_Type *>(&type) != NULL) {

  encoding_buffer.put_c(static_cast<const uint8_t>(uppertester_vru_codec::c_utVamTrigger));

    const Record_Type &r = (const Record_Type &)type;

  uint8_t                                                  flags = 0x00;

    loggers::get_instance().log("uppertester_vru_codec::encode_: processing Record_Type %s", r.get_descriptor()->name);

  OCTETSTRING                                              val;

    for (int i = 0; i < r.get_count(); i++) {

  if (r.setVruProfile().is_present()) {

      loggers::get_instance().log("uppertester_vru_codec::encode_: processing %s/%s/%s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>) - %d", r.fld_name(i),

    flags |= 0x80;

                                  r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name, r.get_at(i)->is_optional(), r.get_at(i)->is_present());

    val = int2oct(r.setVruProfile(), 1);

      if (r.get_at(i)->is_present()) {

  } else if (r.leaveClusterWithCause().is_present()) {

        if (encode_(*r.get_at(i), *r.fld_descr(i), encoding_buffer) == -1) {

    flags |= 0x40;

          loggers::get_instance().warning("uppertester_vru_codec::encode_: -1 result code returned");

    val = int2oct(r.leaveClusterWithCause(), 1);

          return -1;

        }

      } else if (std::string(r.fld_name(i)).compare("alacarte") == 0) {

        // Add empty field length

        loggers::get_instance().log("uppertester_vru_codec::encode_: alacarte is missing, add 0x00");

        encoding_buffer.put_c(0x00);

  }

  }

    } // End of 'for' statement

  encoding_buffer.put_c(flags);

  } else {

  encoding_buffer.put_string(val);

    loggers::get_instance().log("uppertester_vru_codec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());

    type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);

  loggers::get_instance().log_msg("<<< uppertester_vru_codec::encode: data=", data);

  return 0;

}

}





  loggers::get_instance().log_to_hexa("<<<uppertester_vru_codec::encode_: encoding_buffer=", encoding_buffer);

int uppertester_vru_codec::encode(const Record_Type &p_message, OCTETSTRING &p_data) {

  return 0;

  loggers::get_instance().error(">>> uppertester_vru_codec::encode (3)");

  return -1;

}

}





int uppertester_vru_codec::decode(const OCTETSTRING &data, Record_Type &msg, params_its *params) {

int uppertester_vru_codec::decode(const OCTETSTRING &data, Record_Type &msg, params_its *params) {
@@ -99,20 +90,19 @@ std::unique_ptr<Base_Type> uppertester_vru_codec::decode(const OCTETSTRING &data 
}

}





int uppertester_vru_codec::decode(const OCTETSTRING &data, LibItsVru__TypesAndValues::UtVamResults &msg, params_its *params) {

int uppertester_vru_codec::decode(const OCTETSTRING &data, LibItsVru__TypesAndValues::UtVamResults &msg, params_its *params) {

  loggers::get_instance().log_to_hexa(">>> uppertester_vru_codec::decode: decoding_buffer=", data);

  loggers::get_instance().log_to_hexa(">>> uppertester_vru_codec::decode (3): decoding_buffer=", data);





  const uint8_t *ptr = static_cast<const uint8_t *>(data);

  const uint8_t *ptr = static_cast<const uint8_t *>(data);

  if (*ptr == uppertester_vru_codec::c_utVamInitializeResult) {

  if (*ptr == uppertester_vru_codec::c_utVamInitializeResult) {

    msg.utVamInitializeResult() = BOOLEAN(*(ptr + 1) == 0x01);

    msg.utVamInitializeResult() = BOOLEAN(*(ptr + 1) == 0x01);

  } else if (*ptr == 0x24) { // TODO Use a constant for "Peer does not support is "Peer does not support the command"

  } else if (*ptr == uppertester_vru_codec::c_utVamTriggerResult) {

    // Peer does not support the command

    msg.utVamTriggerResult() = BOOLEAN(*(ptr + 1) == 0x01);

    msg.utVamInitializeResult() = 0x00;

  } else {

  } else {

    loggers::get_instance().warning("uppertester_vru_codec::decode: Unsupported result");

    loggers::get_instance().warning("uppertester_vru_codec::decode (3): Unsupported result");

    return -1;

    return -1;

  }

  }





  loggers::get_instance().log_msg("<<< uppertester_vru_codec::decode", msg);

  loggers::get_instance().log_msg("<<< uppertester_vru_codec::decode (3): ", msg);

  return 0;

  return 0;

}

}