Commit 10b6a8d4 authored by garciay's avatar garciay
Browse files

Update test suite to validate codecs

parent fad5c0f1

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc

+107 −57
Original line number Diff line number Diff line
@@ -6,86 +6,136 @@ 


int GeoNetworkingCodec::encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data)

{

    loggers::loggers::log_msg("GeoNetworkingCodec::encode: ", (const Base_Type&)msg);

    loggers::loggers::log_msg(">>> GeoNetworkingCodec::encode: ", (const Base_Type&)msg);

    TTCN_Buffer encoding_buffer;

    encode_(msg, encoding_buffer);

    encode_(msg, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu_descr_, encoding_buffer);

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

    return 0;

}

int GeoNetworkingCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg)

{

    loggers::loggers::log("GeoNetworkingCodec::decode");

    loggers::loggers::log(">>> GeoNetworkingCodec::decode");

    return 0;

}



int GeoNetworkingCodec::encode_ (const Base_Type& type, TTCN_Buffer& encoding_buffer)

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

{

    loggers::loggers::log(">>> GeoNetworkingCodec::encode_: processing %s", type.get_descriptor()->name);

    loggers::loggers::log_msg("GeoNetworkingCodec::encode_: ", type);

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

    loggers::loggers::log_msg(">>> GeoNetworkingCodec::encode_: ", type);



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

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

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

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

            loggers::loggers::log("GeoNetworkingCodec::encode_: processing %s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>)", r.fld_name(i), r.get_at(i)->is_optional());

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

            loggers::loggers::log("GeoNetworkingCodec::encode_: processing %s/%s/%s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>) - %d", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name, r.get_at(i)->is_optional(), r.get_at(i)->is_present());

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

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

            		return -1;

            	}

            }

        } // End of 'for' statement

    } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.ExtendedHeader") == 0) {

        const OPTIONAL<LibItsGeoNetworking__TypesAndValues::ExtendedHeader> &v = dynamic_cast<const OPTIONAL<LibItsGeoNetworking__TypesAndValues::ExtendedHeader> &>(type);

        const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u = static_cast<const LibItsGeoNetworking__TypesAndValues::ExtendedHeader &>(*v.get_opt_value());

        loggers::loggers::log("GeoNetworkingCodec::encode_: ExtendedHeader present: %d", v.is_present());

        if (v.is_present()) {

            if (encode_extendedHeader(static_cast<const LibItsGeoNetworking__TypesAndValues::ExtendedHeader &>(*v.get_opt_value()), encoding_buffer) == -1) {

                return -1;

            }

        }

    } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.Payload") == 0) {

        const OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &v = dynamic_cast<const OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &>(type);

        loggers::loggers::log("GeoNetworkingCodec::encode_: Payload present: %d", v.is_present());

        if (v.is_present()) {

            if (encode_(static_cast<const LibItsGeoNetworking__TypesAndValues::Payload &>(*v.get_opt_value()), LibItsGeoNetworking__TypesAndValues::Payload_descr_, encoding_buffer) == -1) {

                return -1;

            }

        }

    } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.DecodedPayload") == 0) {

        const OPTIONAL<LibItsGeoNetworking__TypesAndValues::DecodedPayload> &v = dynamic_cast<const OPTIONAL<LibItsGeoNetworking__TypesAndValues::DecodedPayload> &>(type);

        loggers::loggers::log("GeoNetworkingCodec::encode_: DecodedPayload present: %d", v.is_present());

        if (v.is_present()) {

            if (encode_decodedPayload(static_cast<const LibItsGeoNetworking__TypesAndValues::DecodedPayload &>(*v.get_opt_value()), encoding_buffer) == -1) {

                return -1;

            }

        }

    } else {

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

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

    }

    loggers::loggers::log_to_hexa("GeoNetworkingCodec::encode_: encoding_buffer=", encoding_buffer);



    return 0;

}



int GeoNetworkingCodec::encode_extendedHeader(const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& encoding_buffer) {

    loggers::loggers::log(">>> GeoNetworkingCodec::encode_extendedHeader: processing %s", u.get_descriptor()->name);



    int result = -1;

    switch (u.get_selection()) {

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::UNBOUND_VALUE:

                TTCN_error("Invalid selection in unbound union");

            TTCN_error("GeoNetworkingCodec::encode_extendedHeader: Invalid selection in unbound union");

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoUnicastHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.geoUnicastHeader().get_descriptor()->name);

                result = encode_(u.geoUnicastHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.geoUnicastHeader().get_descriptor()->name);

            result = encode_(u.geoUnicastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoUnicastHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_tsbHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.tsbHeader().get_descriptor()->name);

                result = encode_(u.tsbHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.tsbHeader().get_descriptor()->name);

            result = encode_(u.tsbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_tsbHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_shbHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.shbHeader().get_descriptor()->name);

                result = encode_(u.shbHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.shbHeader().get_descriptor()->name);

            result = encode_(u.shbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_shbHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoBroadcastHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.geoBroadcastHeader().get_descriptor()->name);

                result = encode_(u.geoBroadcastHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.geoBroadcastHeader().get_descriptor()->name);

            result = encode_(u.geoBroadcastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoBroadcastHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoAnycastHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.geoAnycastHeader().get_descriptor()->name);

                result = encode_(u.geoAnycastHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.geoAnycastHeader().get_descriptor()->name);

            result = encode_(u.geoAnycastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoAnycastHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_beaconHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.beaconHeader().get_descriptor()->name);

                result = encode_(u.beaconHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.beaconHeader().get_descriptor()->name);

            result = encode_(u.beaconHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_beaconHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_anyHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.anyHeader().get_descriptor()->name);

                result = encode_(u.anyHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.anyHeader().get_descriptor()->name);

            result = encode_(u.anyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_anyHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsRequestHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.lsRequestHeader().get_descriptor()->name);

                result = encode_(u.lsRequestHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.lsRequestHeader().get_descriptor()->name);

            result = encode_(u.lsRequestHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsRequestHeader_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsReplyHeader:

                loggers::loggers::log("GeoNetworkingCodec::encode_: processing type %s", u.lsReplyHeader().get_descriptor()->name);

                result = encode_(u.lsReplyHeader(), encoding_buffer);

            loggers::loggers::log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.lsReplyHeader().get_descriptor()->name);

            result = encode_(u.lsReplyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsReplyHeader_descr_, encoding_buffer);

            break;

            default: TTCN_error("Invalid selection in union is_bound");

        default: TTCN_error("GeoNetworkingCodec::encode_extendedHeader: Invalid selection in union is_bound");

    } // End of 'switch' statement

        if (result == -1) {

            return -1;

        }

    } else {

        loggers::loggers::log("GeoNetworkingCodec::encode_ (else): processing type %s", type.get_descriptor()->name);

        type.encode(*type.get_descriptor(), encoding_buffer, TTCN_EncDec::CT_RAW);



    return result;

}

    loggers::loggers::log_to_hexa("GeoNetworkingCodec::encode_: encoding_buffer=", encoding_buffer);



    return 0;

int GeoNetworkingCodec::encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer) {

    loggers::loggers::log(">>> GeoNetworkingCodec::encode_decodedPayload: processing %s", u.get_descriptor()->name);



    int result = -1;

    switch (u.get_selection()) {

        case LibItsGeoNetworking__TypesAndValues::DecodedPayload::UNBOUND_VALUE:

            TTCN_error("GeoNetworkingCodec::encode_decodedPayload: Invalid selection in unbound union");

            break;

        case LibItsGeoNetworking__TypesAndValues::DecodedPayload::ALT_ipv6Packet:

            loggers::loggers::log("GeoNetworkingCodec::encode_decodedPayload: processing type %s", u.ipv6Packet().get_descriptor()->name);

            //result = encode_(u.geoUnicastHeader(), LibItsGeoNetworking__TypesAndValues::DecodedPayload_ipv6Packet_descr_, encoding_buffer);

            break;

        case LibItsGeoNetworking__TypesAndValues::DecodedPayload::ALT_btpPacket:

            loggers::loggers::log("GeoNetworkingCodec::encode_decodedPayload: processing type %s", u.btpPacket().get_descriptor()->name);

            //result = encode_(u.geoUnicastHeader(), LibItsGeoNetworking__TypesAndValues::DecodedPayload_btpPacket_descr_, encoding_buffer);

            break;

        default: TTCN_error("GeoNetworkingCodec::encode_decodedPayload: Invalid selection in union is_bound");

    } // End of 'switch' statement



    return result;

}

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.hh

+4 −1
Original line number Diff line number Diff line
@@ -4,7 +4,10 @@ 
#include "Codec.h"



class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu> {

	int encode_ (const Base_Type& type, TTCN_Buffer& encoding_buffer);

	int encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer);

	int encode_extendedHeader(const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& encoding_buffer);

	int encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer);



public:

  virtual int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu&, OCTETSTRING& data);

  virtual int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu&);