validate and bug fixes MEC016

/*!

 * \file      json_codec_factory_mec013.hh

 * \brief     Header file for ITS JSON/IP protocol codec factory.

 * \author    ETSI STF569 / TTF T027

 * \copyright ETSI Copyright Notification

 *            No part may be reproduced except as authorized by written permission.

 *            The copyright and the foregoing restriction extend to reproduction in all media.

 *            All rights reserved.

 * \version   0.1

 */

#pragma once

#include "codec_stack_builder.hh"

#include "json_codec_mec016.hh"

class Record_Type; //! TITAN forward declaration

/*!

 * \class json_codec_factory_mec013

 * \brief  This class provides a factory class to create an json_codec class instance

 */

class json_codec_factory_mec016: public codec_factory {

  static json_codec_factory_mec016 _f; //! Reference to the unique instance of this class

public: //! \publicsection

  /*!

   * \brief Default constructor

   *        Create a new instance of the json_codec_factory_mec013 class

   * \remark The HELD/IP codec identifier is HELD

   */

  json_codec_factory_mec016() {

    // register factory

    codec_stack_builder::register_codec_factory("json_codec_mec016", this);

  };

  /*!

   * \fn codec* create_codec(const std::string & type, const std::string & param);

   * \brief  Create the codecs stack based on the provided codecs stack description

   * \param[in] p_type The provided codecs stack description

   * \param[in] p_params Optional parameters

   * \return 0 on success, -1 otherwise

   * \inline

   */

  inline virtual codec_gen<Record_Type, Record_Type>* create_codec() {

    return (codec_gen<Record_Type, Record_Type>*)new json_codec_mec016();

  };

}; // End of class json_codec_factory_mec013

#include <stdexcept>

#include <regex>

#include <string>

#include "json_codec_factory_mec016.hh"

#include "loggers.hh"

#include "LibHttp_JsonMessageBodyTypes.hh"

int json_codec_mec016::encode(const LibHttp__JsonMessageBodyTypes::JsonBody& msg, OCTETSTRING& data) {

  loggers::get_instance().log_msg(">>> json_codec_mec016::encode: ", (const Base_Type&)msg);

  TTCN_EncDec::clear_error();

  TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_DEFAULT);

  TTCN_Buffer encoding_buffer;

  // Application Context

  if (msg.ischosen(LibHttp__JsonMessageBodyTypes::JsonBody::ALT_appContext__device__info)) {

    const DeviceApplicationInterfaceAPI__TypesAndValues::AppContext& ctx = msg.appContext__device__info();

    ctx.encode(DeviceApplicationInterfaceAPI__TypesAndValues::AppContext_descr_, encoding_buffer, TTCN_EncDec::CT_JSON);

    //data = char2oct(CHARSTRING("{\"appContext\": ")) + OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data()) + char2oct(CHARSTRING("}"));

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

  } else if (msg.ischosen(LibHttp__JsonMessageBodyTypes::JsonBody::ALT_applicationLocationAvailability)) {

    const DeviceApplicationInterfaceAPI__TypesAndValues::ApplicationLocationAvailability& ctx = msg.applicationLocationAvailability();

    ctx.encode(DeviceApplicationInterfaceAPI__TypesAndValues::ApplicationLocationAvailability_descr_, encoding_buffer, TTCN_EncDec::CT_JSON);

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

  } 

  // // Fallback to generic codec

  else {

    return json_codec::encode(msg, data);

  }

  loggers::get_instance().log("<<< json_codec_mec016::encode");

  return 0;

}

int json_codec_mec016::decode (const OCTETSTRING& p_data, LibHttp__JsonMessageBodyTypes::JsonBody& msg, params* p_params) {

  loggers::get_instance().log_msg(">>> json_codec_mec016::decode: p_data=", p_data);

  // Sanity checks

  params::const_iterator it;

  if (p_params == nullptr) {

    loggers::get_instance().warning("json_codec_mec016::decode: Failed to access p_params (null pointer)");

    return -1; // TODO Use p_data instead of return -1

  } else {

    it = p_params->find("decode_str");

    if (it == p_params->cend()) {

      loggers::get_instance().warning("json_codec_mec016::decode: Failed to access p_params item (decode_str)");

      return -1; // TODO Use p_data instead of return -1

    }

    loggers::get_instance().log("json_codec_mec016::decode: it->second='%c' / '%s'", it->second.c_str()[0], it->second.c_str());

  }

  // Remove data structure name (if present) ...

  std::string str;

  if ((it->second[0] != '[') && (it->second[0] != '{')) {

    int idx_begin = it->second.find(":");

    int idx_end = it->second.rfind("}") - 1; // Remove the last '}'

    str = it->second.substr(idx_begin + 1, idx_end - idx_begin);

  } else {

    str = it->second;

  }

  TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL, TTCN_EncDec::EB_DEFAULT);

  TTCN_EncDec::clear_error();

  loggers::get_instance().log("json_codec_mec016::decode: decoding_buffer='%c' / '%s'", str[0], str.c_str());

  TTCN_Buffer decoding_buffer(OCTETSTRING(str.size(), (const unsigned char*)str.c_str()));

  // Determine body type by finding JSON field name

  if ((str.find("\"userAppInstanceInfo\"") != std::string::npos) && (str.find("\"appInfo\"") != std::string::npos)) {

    DeviceApplicationInterfaceAPI__TypesAndValues::AppContext ctx;

    ctx.decode(DeviceApplicationInterfaceAPI__TypesAndValues::AppContext_descr_, decoding_buffer, TTCN_EncDec::CT_JSON);

    msg.appContext__device__info() = ctx;

  } else if ((str.find("\"appList\"") != std::string::npos) && (str.find("\"appInfo\"") != std::string::npos)) {

    DeviceApplicationInterfaceAPI__TypesAndValues::ApplicationList ctx;

    ctx.decode(DeviceApplicationInterfaceAPI__TypesAndValues::ApplicationList_descr_, decoding_buffer, TTCN_EncDec::CT_JSON);

    msg.applicationList() = ctx;

  } else if ((it->second.find("\"appInfo\"") != std::string::npos) && (str.find("\"availableLocations\"") != std::string::npos)) {

    DeviceApplicationInterfaceAPI__TypesAndValues::ApplicationLocationAvailability application_location_availability;

    application_location_availability.decode(DeviceApplicationInterfaceAPI__TypesAndValues::ApplicationLocationAvailability_descr_, decoding_buffer, TTCN_EncDec::CT_JSON);

    msg.applicationLocationAvailability() = application_location_availability;

  } else {

    return json_codec::decode(p_data, msg, p_params);

  }

  loggers::get_instance().log_msg("<<< json_codec_mec016::decode: ", (const Base_Type&)msg);

  return 0;

}

// Register codec factory

json_codec_factory_mec016 json_codec_factory_mec016::_f;

#pragma once

#include "codec_gen.hh"

#include "params.hh"

#include "json_codec.hh"

class Base_Type;

class TTCN_Typedescriptor_t;

class TTCN_Buffer;

namespace LibHttp__JsonMessageBodyTypes {

  class JsonBody;

}

class json_codec_mec016: public json_codec

{

public:

  explicit json_codec_mec016() : json_codec() { };

  virtual ~json_codec_mec016() { };

  int encode (const LibHttp__JsonMessageBodyTypes::JsonBody&, OCTETSTRING& data);

  int decode (const OCTETSTRING& p_data, LibHttp__JsonMessageBodyTypes::JsonBody&, params* p_params = NULL);

}; // End of class json_codec_mec013

  json_codec_mec011.cc \

  json_codec_mec011.cc \

  json_codec_mec013.cc \

  json_codec_mec013.cc \

  json_codec_mec015.cc \

  json_codec_mec015.cc \

  json_codec_mec016.cc \

  json_codec_mec030.cc \

  json_codec_mec030.cc \

  json_codec_mec028.cc \

  json_codec_mec028.cc \

  json_codec_mec040.cc \

  json_codec_mec040.cc \

[MODULE_PARAMETERS]

# This section shall contain the values of all parameters that are defined in your TTCN-3 modules.

# IUT roles

LibCommon_Time.PX_TAC := 30.0

#LibCommon_Time.PX_TWAIT := 30.0

LibCommon_Sync.PX_TSYNC_TIME_LIMIT := 30.0;

LibCommon_Sync.PX_TSHUT_DOWN_TIME_LIMIT := 30.0;

LibHttp_Pics.PICS_HEADER_HOST := "192.168.40.50"

LibHttp_Pics.PICS_HEADER_CONTENT_TYPE := "application/json"

LibHttp_Pics.PICS_USE_TOKEN_HEADER    := true

#LibHttp_Pics.PICS_TOKEN_HEADER        := "Basic WrongToken"

#LibMec_Pics.PICS_ROOT_API             := "/sbxnfzm34p/mep1/"

# LibMec_Pixits

DeviceApplicationInterfaceAPI_Pixits.PX_APP_INSTANCE_ID := "81c51643-8c6f-4781-ad45-f8a457ca549b"

# DeviceApplicationInterfaceAPI_Pixits.PX_APPD_ID := "onboarded-demo4"

# DeviceApplicationInterfaceAPI_Pixits.PX_APP_DESCRIPTION := "Basic HTTP"

# DeviceApplicationInterfaceAPI_Pixits.PX_APP_PROVIDER := "demo"

# DeviceApplicationInterfaceAPI_Pixits.PX_ASSOCIATE_DEV_APPID := "bcee2135-2750-4d23-b786-a3062a371c8a"

[LOGGING]

# In this section you can specify the name of the log file and the classes of events

# you want to log into the file or display on console (standard error).

LogFile := "../logs/AtsMec_DeviceApplicationInterface/%e.%h-%r.%s"

FileMask := LOG_ALL | USER | DEBUG | MATCHING

ConsoleMask := LOG_ALL | USER | DEBUG | MATCHING

#FileMask := ERROR | WARNING | USER | MATCHING | EXECUTOR_RUNTIME | VERDICTOP | PORTEVENT | TESTCASE

#ConsoleMask := ERROR | WARNING | USER | MATCHING | EXECUTOR_RUNTIME | VERDICTOP | PORTEVENT | TESTCASE

LogSourceInfo := Stack

LogEntityName:= Yes

LogEventTypes:= Yes

#TimeStampFormat := DateTime

[TESTPORT_PARAMETERS]

# In this section you can specify parameters that are passed to Test Ports.

system.httpPort.params := "HTTP(codecs=json:json_codec_mec016)/TCP(debug=1,server=192.168.40.50,port=80,use_ssl=0)"

#system.httpPort.params := "HTTP(codecs=json:json_codec)/TCP(debug=1,server=try-mec.etsi.org,port=443,use_ssl=1)"

#system.httpPort_notif.params := "HTTP(codecs=json:json_codec_mec015)/TCP(debug=1,server_mode=1,use_ssl=0)"

[DEFINE]

# In this section you can create macro definitions,

# that can be used in other configuration file sections except [INCLUDE] and [ORDERED_INCLUDE].

[INCLUDE]

# To use configuration settings given in other configuration files,

# the configuration files just need to be listed in this section, with their full or relative pathnames.

[ORDERED_INCLUDE]

# To use configuration settings given in other configuration files,

# the configuration files just need to be listed in this section, with their full or relative pathnames.

[EXTERNAL_COMMANDS]

# This section can define external commands (shell scripts) to be executed by the ETS

# whenever a control part or test case is started or terminated.

#BeginTestCase := ""

#EndTestCase := ""

#BeginControlPart := ""

#EndControlPart := ""

[EXECUTE]

# In this section you can specify what parts of your test suite you want to execute.

#AtsMec_TestControl.control

# Check that the IUT responds with the list of user applications when requested by an UE Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPS_001_OK

# Check that the IUT responds with an error when a request for an unknown URI is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPS_001_NF

# Check that the IUT responds with the list of user applications when requested by an UE Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPS_002_OK

# Check that the IUT responds with an error when a request for an unknown URI is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPS_002_BR

#Check that the IUT acknowledges the creation of the application context when requested by an UE Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_001_OK

# Check that the IUT responds with an error when a request with incorrect URL is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_001_BR

# Check that the IUT responds with an error when a request with incorrect URL is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_001_NF

# Check that the IUT acknowledges the creation of the application context when requested by an UE Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_002_OK

# Check that the IUT responds with an error when a request with incorrect parameters is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_002_BR

# Check that the IUT responds with an error when a request for an unknown URI is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_002_NF

# Check that the IUT deletes the application context when commanded by an UE Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_003_OK

# Check that the IUT responds with an error when a request for an unknown URI is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPCTX_003_NF

# Check that the IUT sends the locations available for instantiation of a specific user application when requested by an UE Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPLOC_001_OK

# Check that the IUT responds with an error when a request with incorrect parameters is sent by a MEC Application

#AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPLOC_001_BR

# Check that the IUT responds with an error when a request with incorrect parameters is sent by a MEC Application

AtsMec_DeviceApplicationInterfaceAPI_TestCases.TC_MEC_MEC016_MEO_UEAPPLOC_001_NF

[GROUPS]

# In this section you can specify groups of hosts. These groups can be used inside the

# [COMPONENTS] section to restrict the creation of certain PTCs to a given set of hosts.

[COMPONENTS]

# This section consists of rules restricting the location of created PTCs.

[MAIN_CONTROLLER]

# The options herein control the behavior of MC.

KillTimer := 10.0

LocalAddress := 127.0.0.1

TCPPort := 12000

NumHCs := 1