Removed deprecated files.

build_test.sh

@@ -3,12 +3,6 @@
 # Generate sources using the EAMS plugin.
 mkdir -p ./build/EAMS
 protoc --plugin=protoc-gen-eams=protoc-gen-eams -I./test/proto --eams_out=./build/EAMS ./test/proto/simple_types.proto
-protoc --plugin=protoc-gen-eams=protoc-gen-eams -I./test/proto --eams_out=./build/EAMS ./test/proto/nested_message.proto
-
-# For validation generate the same message using google code.
-mkdir -p ./build/google
-protoc -I./test/proto --cpp_out=./build/google ./test/proto/simple_types.proto
-protoc -I./test/proto --cpp_out=./build/google ./test/proto/nested_message.proto
 
 # Build the tests
 mkdir -p build/test

src/Field.h

@@ -1,268 +0,0 @@
-
-
-#ifndef _FIELD_H_
-#define _FIELD_H_
-
-#include <cstdint>
-#include <limits> 
-#include <type_traits>
-#include <math.h> 
-#include <MessageBufferInterface.h>
-
-namespace EmbeddedProto
-{
-
-  //! Definitions of the different encoding types used in protobuf.
-  enum class WireType 
-  {
-    VARINT            = 0,  //!< int32, int64, uint32, uint64, sint32, sint64, bool, enum.
-    FIXED64           = 1,  //!< fixed64, sfixed64, double
-    LENGTH_DELIMITED  = 2,  //!< string, bytes, embedded messages, packed repeated fields
-    START_GROUP       = 3,  //!< Depricated
-    END_GROUP         = 4,  //!< Depricated
-    FIXED32           = 5,  //!< fixed32, sfixed32, float
-  };
-
-  //! The base class for any type of field.
-  /*!
-      This class defines the basic structor for any type of field, that includes the basic types
-      but also nested messages
-  */
-  class Field 
-  {
-    public:
-
-      //! Possible return values of the (de)serialization functions of a field.
-      enum class Result {
-          OK,
-          ERROR_BUFFER_TO_SMALL,
-      };
-      
-      //! The default constructor which sets the wire type and field number of this field.
-      Field(const WireType type, const uint32_t number) :
-          _wire_type(type),
-          _field_number(number)
-      {
-
-      }
-
-      //! The default destructor.
-      virtual ~Field() = default;
-
-      //! Function to serialize this field including the tag.
-      /*!
-          The data this field holds will be serialized into an byte array.
-
-          \param[in,out] buffer A reference to the buffer which can be used ot serialize the data.
-
-          \return An enum value indicating successful operation of this function or an error.
-      */
-      virtual Result serialize(MessageBufferInterface& buffer) const = 0;
-
-      //! From the buffer desirialize a tag.
-      /*!
-          This function returns the tag value, the combination of the field number and wire type.
-          \param[out] tag The variable in which the tag value is returned. 
-          \param[in,out] buffer The data buffer from which to deseriale the tag.
-          \return An enum value indicating successful operation of this function or an error.
-      */
-      static Result deserialize_tag(uint32_t& tag, MessageBufferInterface& buffer) 
-      {
-        return _deserialize_varint(tag, buffer) ? Result::OK : Result::ERROR_BUFFER_TO_SMALL;
-      }
-
-      //! Function to deserialize this field excluding the tag.
-      /*!
-          From an array of bytes fill this field object with data.
-          
-          \param[in,out] buffer A reference to the buffer which is used to deserialize the data.
-
-          \return An enum value indicating successful operation of this function or an error.
-      */
-      virtual Result deserialize(MessageBufferInterface& buffer) = 0;
-
-      //! Clear the content of this field and set it to it's default state.
-      /*!
-          The defaults are to be set according to the Protobuf standard.
-      */
-      virtual void clear() = 0;
-
-      //! Calculate the size of this field as if it was serialized, tag + data.
-      /*!
-          \return The number of bytes this field will takeup in total when serialized.
-      */
-      virtual uint32_t serialized_size() const
-      { 
-        return tag_size() + serialized_data_size();
-      }
-
-      //! Calculate the size of the data when serialized.
-      /*!
-          \return The number of bytes the data of this field will takeup when serialized.
-      */
-      virtual uint32_t serialized_data_size() const = 0;
-
-    protected:
-
-      //! The maximum number of bits the WireType will takeup.
-      /*!
-          The maximum value of a wire type is five. Three bits are thus required to endonce it.
-      */
-      static constexpr uint8_t WIRE_TYPE_BIT_SIZE = 3;
-
-      //! Definition of a mask inidicating the most significat bit used in varint encoding.
-      /*!
-          \see _serialize_varint() _deserialize_varint()
-      */
-      static constexpr uint8_t VARINT_MSB_BYTE = 0x80;
-
-      //! Definitation of the number of bits it takes to serialize a byte of a varint.
-      /*!
-          \see _serialize_varint() _deserialize_varint()
-      */      
-      static constexpr uint8_t VARINT_SHIFT_N_BITS = 7;
-
-      //! The maximum value which can be stored in a signle byte in base 128 encoding.
-      static constexpr uint8_t VARINT_MAX_SINGLE_BYTE = 
-                                    static_cast<uint8_t>(~VARINT_MSB_BYTE);
-
-      //! Create the tag of a field. 
-      /*!
-        This is the combination of the field number and wire type of the field. The field number is 
-        shifted to the left by three bits. This creates space to or the wire type of the designated 
-        field.
-      */
-      const uint32_t tag() const 
-      {
-        return ((static_cast<uint32_t>(_field_number) << WIRE_TYPE_BIT_SIZE)
-                | static_cast<uint32_t>(_wire_type));
-      }
-
-      //! Calculate the number of bytes required to encode the given varint value.
-      /*!
-          The tag is encoded as a varint and anything below 127 will only take one byte.
-          \warning This is a short cut and large field numbers are not supported at this moment.
-          This function only operates on unsigned values.
-          \param[in] value The value for which we would like to know the number of bytes.
-          \return Then required number of bytes to encode the value. 
-      */
-      template<class VAR_UINT_TYPE>
-      const uint32_t serialized_size_varint(const VAR_UINT_TYPE& value) const
-      {
-          static_assert(std::is_unsigned<VAR_UINT_TYPE>::value, "Varint size calculation is only "
-                                                          " possible for unsigned integer types.");
-
-          uint32_t n_bytes_required = 0;
-          VAR_UINT_TYPE v = value;
-
-          while(v > 0) {
-            v = v >> VARINT_SHIFT_N_BITS;
-            ++n_bytes_required;
-          }
-
-          return n_bytes_required;
-      }
-
-      //! Return the number of bytes the tag of this field will need.
-      const uint8_t tag_size() const
-      { 
-        return serialized_size_varint(tag());
-      }
-
-      //! Obtain the wire type of this field.
-      const WireType wireType() const 
-      {
-        return _wire_type;
-      }
-
-      //! Obtain the field number of this field.
-      const uint32_t fieldNumber() const
-      {
-        return _field_number;
-      }
-
-      //! This function converts a given value int a varint formated data array.
-      /*!
-        This function only accepts unsigned integers.
-
-        \param[in] value  The data to be serialized.
-        \param[in,out] buffer The data buffer in which the varint is stored.
-        \return True when serilization succedded, false otherwise.
-      */
-      template<class VARINT_TYPE>
-      static bool _serialize_varint(VARINT_TYPE value, MessageBufferInterface& buffer)
-      {
-        static_assert(std::is_unsigned<VARINT_TYPE>::value, "Varint encoding only possible for "
-                                                            "unsigned integer types.");
-        bool result(true);
-
-        while((value >= VARINT_MSB_BYTE) && result) 
-        {
-          result = buffer.push(static_cast<uint8_t>(value | VARINT_MSB_BYTE));
-          value >>= VARINT_SHIFT_N_BITS;
-        }
-        result = buffer.push(static_cast<uint8_t>(value));
-
-        return result;
-      }
-
-      //! This function converts a given buffer into an integer value.
-      /*!
-        This function only accepts unsigned integers.
-
-        \param[in] value  Variable in which the deserialized unsigned integer is returned.
-        \param[in,out] buffer The data set from which to obtain the value.
-        \return True when deserialization succedded.
-      */
-      template<class VARINT_TYPE>
-      static bool _deserialize_varint(VARINT_TYPE& value, MessageBufferInterface& buffer)
-      {
-        static_assert(std::is_unsigned<VARINT_TYPE>::value, "Varint encoding only possible for "
-                                                            "unsigned integer types.");
-
-        // Calculate how many bytes there are in a varint 128 base encoded number. This should 
-        // yeild 5 for a 32bit number and 10 for a 64bit number.
-        static constexpr uint8_t N_BYTES_IN_VARINT = static_cast<uint8_t>(std::ceil(
-                                                          std::numeric_limits<VARINT_TYPE>::digits 
-                                                        / static_cast<float>(VARINT_SHIFT_N_BITS)));
-        
-        VARINT_TYPE temp_value = 0;
-        uint8_t byte = 0;
-        bool result = buffer.pop(byte);
-        // Loop until the end of the encoded varint or until there is nomore data in the buffer.
-        for(uint8_t i = 0; (i < N_BYTES_IN_VARINT) && result; ++i) 
-        {
-          temp_value |= static_cast<VARINT_TYPE>(byte & (~VARINT_MSB_BYTE)) << (i * VARINT_SHIFT_N_BITS);
-          if(byte & VARINT_MSB_BYTE) 
-          {
-            // Continue
-            result = buffer.pop(byte);
-          }
-          else
-          {
-            // The varint is complete
-            break;
-          }
-        }
-
-        if(result)
-        {
-          value = temp_value;
-        }
-
-        return result;
-      }
-
-    private:
-
-      //! The wire type of this field.
-      const WireType _wire_type;
-
-      //! The field number of this field.
-      const uint32_t _field_number;
-
-  };
-
-} // End of namespace EmbeddedProto
-
-#endif 

src/FieldBool.h

@@ -1,122 +0,0 @@
-
-#ifndef _FIELD_BOOL_H_
-#define _FIELD_BOOL_H_
-
-#include "Field.h"
-
-namespace EmbeddedProto
-{
-
-  namespace Detail 
-  {
-
-    //! The field type for booleans.
-    class FieldBool : public Field 
-    {
-      private:        
-          //! The Protobuf default value for this type. Zero in this case.
-          static constexpr bool DEFAULT_VALUE = false;
-
-          //! The number of bytes required to serialize one boolean.
-          static constexpr uint32_t N_BYTES_IN_BOOL = 1;
-
-          //! The byte as serialized for a bool equal to true.
-          static constexpr uint8_t BOOL_BYTE_TRUE = 0x01;
-
-      public:
-
-          //! Constructor which also sets the field id number of this field.
-          /*!
-              \param[in] The field id number as specified in the *.proto file.
-          */
-          FieldBool(const uint32_t number) :
-              Field(WireType::VARINT, number),
-              _data(DEFAULT_VALUE)
-          {
-
-          }
-
-          //! The constructor is default as we do not have members with non standart memory allocation.
-          ~FieldBool() final = default;
-
-          //! Set the value of this field
-          void set(const bool& value)
-          {
-            _data = value;
-          }
-
-          //! Assignment opertor to set the data.
-          FieldBool& operator=(const bool& value)
-          {
-            set(value);
-            return *this;
-          }
-
-          //! Obtain the value of this field.
-          const bool& get() const
-          {
-            return _data; 
-          }
-
-          //! \see Field::serialize()
-          Result serialize(MessageBufferInterface& buffer) const final
-          {
-            Result result(Result::OK);
-            // Only serialize if the data does not equal the default and when the size in the buffer 
-            // is sufficient.
-            if(DEFAULT_VALUE != _data)
-            {
-              if(serialized_size() <= buffer.get_max_size()) 
-              {
-                _serialize_varint(tag(), buffer);
-                buffer.push(BOOL_BYTE_TRUE);
-              }
-              else 
-              {
-                result = Result::ERROR_BUFFER_TO_SMALL;
-              }
-            }
-            return result;
-          }
-
-          //! \see Field::deserialize()
-          Result deserialize(MessageBufferInterface& buffer) final
-          {
-            // Check if there is enough data in the buffer for a fixed value.
-            bool result = N_BYTES_IN_BOOL <= buffer.get_size();
-            if(result) {
-              uint8_t byte = 0;
-              buffer.pop(byte);
-              _data = BOOL_BYTE_TRUE == byte;
-            }
-
-            return result ? Result::OK : Result::ERROR_BUFFER_TO_SMALL;
-          }
-
-          //! \see Field::clear()
-          void clear() final
-          {
-            _data = DEFAULT_VALUE;
-          }
-
-          //! \see Field::serialized_data_size()
-          uint32_t serialized_data_size() const final
-          {
-            return N_BYTES_IN_BOOL;
-          }
-
-
-      private:
-
-          //! The actual data.
-          bool _data;
-    };
-
-  } // End of namespace detail
-
-  //! A short hand definition of the boolean type.
-  typedef Detail::FieldBool boolean;
-
-} // End of namespace EmbeddedProto
-
-#endif // End of _FIELD_BOOL_H_

src/FieldEnum.h

@@ -1,123 +0,0 @@
-
-#ifndef _FIELD_ENUM_H_
-#define _FIELD_ENUM_H_
-
-#include "Field.h"
-
-#include <type_traits>
-
-
-namespace EmbeddedProto
-{
-
-  namespace Detail 
-  {    
-    //! The field type for enumerations normal and class enums.
-    template<class ENUM_TYPE>
-    class FieldEnum : public Field 
-    {
-      private:
-        static_assert(std::is_enum<ENUM_TYPE>::value, "This class only supports enum and enum "
-                                                      "classes as template parameter.");
-
-        //! The actual type of integer used to store this enum underneeth the bonnit.
-        typedef typename std::underlying_type<ENUM_TYPE>::type INT_TYPE;
-
-        //! Initialize the enum always for its default value.
-        /*!
-            Protobuf dictates all enums should have their first item be equal to zero.
-        */
-        static constexpr ENUM_TYPE DEFAULT_VALUE = static_cast<ENUM_TYPE>(0);
-
-      public:
-
-        //! This default constructor sets the 
-        FieldEnum(const uint32_t number) 
-          : Field(WireType::VARINT, number),
-            _data(DEFAULT_VALUE)
-        {
-
-        }
-
-        ~FieldEnum() final = default;
-
-        //! Obtain the current value.
-        const ENUM_TYPE& get() const { return _data; }
-
-        //! Set the enum
-        void set(const ENUM_TYPE& e)
-        {
-          _data = e;
-        }
-
-        //! Assignment opertor to set the data.
-        FieldEnum<ENUM_TYPE>& operator=(const ENUM_TYPE& e)
-        {
-          set(e);
-          return *this;
-        }
-
-        //! \see Field::serialize()
-        Result serialize(MessageBufferInterface& buffer) const final
-        {
-          Result result(Result::OK);
-          // Only serialize if the data does not equal the default and when the size in the buffer 
-          // is sufficient.
-          if(DEFAULT_VALUE != _data)
-          {
-            if(serialized_size() <= buffer.get_max_size()) 
-            {
-              _serialize_varint(tag(), buffer);
-              _serialize_varint(static_cast<INT_TYPE>(_data), buffer);
-            }
-            else 
-            {
-              result = Result::ERROR_BUFFER_TO_SMALL;
-            }
-          }
-          return result;
-        }
-
-        //! \see Field::deserialize()
-        Result deserialize(MessageBufferInterface& buffer) final    
-        {
-          Result result(Result::OK);
-          uint64_t uint_data;
-          if((0 < buffer.get_size()) && _deserialize_varint(uint_data, buffer))
-          {
-            _data = static_cast<ENUM_TYPE>(uint_data);
-          }
-          else
-          {
-            // TODO create a better error for this case. May be an error from _deserialize_varint().
-            result = Result::ERROR_BUFFER_TO_SMALL;
-          }
-          return result;
-        } 
-
-        //! \see Field::clear()
-        void clear() final
-        {
-          _data = DEFAULT_VALUE;
-        }
-
-        //! \see Field::serialized_data_size()
-        uint32_t serialized_data_size() const final
-        {
-          return serialized_size_varint(static_cast<INT_TYPE>(_data));;
-        }   
-
-      private:
-
-        ENUM_TYPE _data; 
-    };
-
-  } // End of namespace detail
-
-  //! Short hand notation to access the Detail namespace for the FieldEnum class.   
-  template<class ENUM_TYPE>
-  using Enumeration = Detail::FieldEnum<ENUM_TYPE>;
-
-} // End of namespace EmbeddedProto
-
-#endif // End of _FIELD_ENUM_H_

src/FieldFixed.h

@@ -1,218 +0,0 @@
-
-#ifndef _FIELD_FIXED_H_
-#define _FIELD_FIXED_H_
-
-#include "Field.h"
-
-namespace EmbeddedProto
-{
-
-  namespace Detail 
-  {
-    //! The field type with fixed length.
-    template<WireType WIRE_TYPE, class DATA_TYPE>
-    class FieldFixed : public Field
-    {
-      protected:
-
-        //! Check if for a fixed field a valid wire type has been supplied.
-        static_assert((WIRE_TYPE == WireType::FIXED64) || (WIRE_TYPE == WireType::FIXED32), 
-                "Invalid wire type supplied in template, only FIXEDXX types are allowed.");
-
-        //! This typedef will return an unsigned 32 or 64 variable depending on the field type.
-        typedef typename std::conditional<WIRE_TYPE == WireType::FIXED32, uint32_t, uint64_t>::type 
-                                                                                  VAR_UINT_TYPE;
-
-        //! This typedef will return a signed 32 or 64 variable depending on the field type.
-        typedef typename std::conditional<WIRE_TYPE == WireType::FIXED32, int32_t, int64_t>::type 
-                                                                                  VAR_INT_TYPE;
-        
-        //! The Protobuf default value for this type. Zero in this case.
-        static constexpr DATA_TYPE DEFAULT_VALUE = static_cast<DATA_TYPE>(0);
-
-        //! The number of bytes in this fixed field.
-        static constexpr uint32_t N_BYTES_IN_FIXED = std::numeric_limits<VAR_UINT_TYPE>::digits 
-                                                          / std::numeric_limits<uint8_t>::digits;
-
-      public:
-
-        //! Constructor which also sets the field id number of this field.
-        /*!
-            \param[in] The field id number as specified in the *.proto file.
-        */
-        FieldFixed(const uint32_t number) :
-            Field(WIRE_TYPE, number),
-            _data(DEFAULT_VALUE)
-        {
-
-        }
-
-        //! The constructor is default as we do not have members with non standart memory allocation.
-        ~FieldFixed() final = default;
-
-        //! Set the value of this field
-        void set(const DATA_TYPE& value)
-        {
-          _data = value;
-        }
-
-        //! Assignment opertor to set the data.
-        FieldFixed& operator=(const DATA_TYPE& value)
-        {
-          set(value);
-          return *this;
-        }
-
-        //! Obtain the value of this field.
-        const DATA_TYPE& get() const
-        {
-          return _data; 
-        }
-
-        //! \see Field::serialize()
-        Result serialize(MessageBufferInterface& buffer) const final
-        {
-          Result result(Result::OK);
-          // Only serialize if the data does not equal the default and when the size in the buffer 
-          // is sufficient.
-          // This if statement would be more comperhensive if we where using C++17 std::abs.
-          if(!(((DEFAULT_VALUE + std::numeric_limits<DATA_TYPE>::epsilon()) >= _data) &&
-               ((DEFAULT_VALUE - std::numeric_limits<DATA_TYPE>::epsilon()) <= _data)))
-          {
-            if(serialized_size() <= buffer.get_max_size()) 
-            {
-              _serialize_varint(tag(), buffer);
-              const void* pVoid = static_cast<const void*>(&_data);
-              const VAR_UINT_TYPE* pUInt = static_cast<const VAR_UINT_TYPE*>(pVoid);
-              _serialize_fixed(*pUInt, buffer);            }
-            else
-            {
-              result = Result::ERROR_BUFFER_TO_SMALL;
-            }
-            
-          }
-          return result;
-        }
-
-        //! \see Field::deserialize()
-        Result deserialize(MessageBufferInterface& buffer) final
-        {
-          // Check if there is enough data in the buffer for a fixed value.
-          bool result = N_BYTES_IN_FIXED <= buffer.get_size();
-          VAR_UINT_TYPE d = 0;
-          result = result && _deserialize_fixed(d, buffer);
-          if(result) {
-            const void* pVoid = static_cast<const void*>(&d);
-            const DATA_TYPE* pData = static_cast<const DATA_TYPE*>(pVoid);
-            _data = *pData;
-          }
-          return result ? Result::OK : Result::ERROR_BUFFER_TO_SMALL;
-        }
-
-        //! \see Field::clear()
-        void clear() final
-        {
-          _data = DEFAULT_VALUE;
-        }
-
-        //! \see Field::serialized_data_size()
-        uint32_t serialized_data_size() const final
-        {
-          return N_BYTES_IN_FIXED;
-        }
-
-
-      protected:
-
-        //! Serialize a single unsigned integer into the buffer using the fixed size method.
-        /*!
-            The fixed size method just pushes every byte into the buffer.
-
-            \param[in] value The variable to serialize.
-            \param[in,out] buffer The data buffer to which the variable is serialized.
-            \return True when serialization succedded.
-        */
-        bool _serialize_fixed(VAR_UINT_TYPE value, MessageBufferInterface& buffer) const
-        {
-          // Write the data little endian to the buffer.
-          // TODO Define a little endian flag to support memcpy the data to the buffer.
-
-          bool result(true);
-          for(uint8_t i = 0; i < std::numeric_limits<VAR_UINT_TYPE>::digits; 
-              i += std::numeric_limits<uint8_t>::digits)  
-          {
-            result = buffer.push(static_cast<uint8_t>((value >> i) & 0x00FF));
-            if(!result)
-            {
-              // No more space in the buffer.
-              break;
-            }
-          }
-          return result;
-        }
-
-        //! Deserialize a fixed length value from the buffer into the given variable.
-        /*!
-            \param[out] value The variable in which the result is returned.
-            \param[in,out] buffer The buffer from which to deserialize the data.
-            \return True when deserialization succedded.
-        */
-        bool _deserialize_fixed(VAR_UINT_TYPE& value, MessageBufferInterface& buffer) const
-        {
-          // Read the data little endian to the buffer.
-          // TODO Define a little endian flag to support memcpy the data from the buffer.
-
-          VAR_UINT_TYPE temp_value = 0;
-          bool result(true);
-          uint8_t byte = 0;
-          for(uint8_t i = 0; i < std::numeric_limits<VAR_UINT_TYPE>::digits; 
-              i += std::numeric_limits<uint8_t>::digits)  
-          {
-            result = buffer.pop(byte);
-            if(result)
-            {
-              temp_value |= static_cast<VAR_UINT_TYPE>(byte) << i;
-            }
-            else
-            {
-              // End of buffer
-              break;
-            }
-          }
-
-          if(result)
-          {
-            value = temp_value;
-          }
-
-          return result;
-        }
-
-
-      private:
-
-        //! The actual data.
-        DATA_TYPE _data;
-
-    };
-
-  } // End of namespace detail
-
-
-  /*!
-    Actually define the types to beused in messages. These specify the template for different field 
-    types.
-    \{
-  */
-  typedef Detail::FieldFixed<WireType::FIXED64, uint64_t> fixed64;
-  typedef Detail::FieldFixed<WireType::FIXED64, int64_t>  sfixed64;
-  typedef Detail::FieldFixed<WireType::FIXED64, double>   double64;
-
-  typedef Detail::FieldFixed<WireType::FIXED32, uint32_t> fixed32;
-  typedef Detail::FieldFixed<WireType::FIXED32, int32_t>  sfixed32;
-  typedef Detail::FieldFixed<WireType::FIXED32, float>    float32;
-  /*! \} */
-
-} // End of namespace EmbeddedProto
-
-#endif

src/FieldVarInt.h

@@ -1,146 +0,0 @@
-
-#ifndef _FIELD_VARINT_H_
-#define _FIELD_VARINT_H_
-
-#include "Field.h"
-
-namespace EmbeddedProto
-{
-
-  namespace Detail 
-  {
-    //! The field type with varint encoding.
-    /*!
-        The variables encoded with this field are: int32, int64, uint32, uint64, sint32, sint64, 
-        bool, enum.
-    */
-    template<class DATA_TYPE>
-    class FieldVarInt : public Field
-    {
-      protected:
-
-        //! The Protobuf default value for this type. Zero in this case.
-        static constexpr DATA_TYPE DEFAULT_VALUE = static_cast<DATA_TYPE>(0);
-
-        //! This typedef will return an unsigned variable depending on the data type.
-        typedef typename std::make_unsigned<DATA_TYPE>::type VAR_UINT_TYPE;
-
-      public:
-
-        //! Constructor which also sets the field id number of this field.
-        /*!
-            \param[in] The field id number as specified in the *.proto file.
-        */
-        FieldVarInt(const uint32_t number) :
-            Field(WireType::VARINT, number),
-            _data(DEFAULT_VALUE)
-        {
-
-        }
-
-        //! The constructor is default as we do not have members with non standart memory allocation.
-        ~FieldVarInt() final = default;
-
-        //! Set the value of this field
-        void set(const DATA_TYPE& value)
-        {
-          _data = value;
-        }
-
-        //! Assignment opertor to set the data.
-        FieldVarInt& operator=(const DATA_TYPE& value)
-        {
-          set(value);
-          return *this;
-        }
-
-        //! Obtain the value of this field.
-        const DATA_TYPE& get() const
-        {
-          return _data; 
-        }
-
-        //! \see Field::serialize()
-        Result serialize(MessageBufferInterface& buffer) const final
-        {
-          Result result(Result::OK);
-          if(DEFAULT_VALUE != _data)
-          {
-            if(serialized_size() <= buffer.get_max_size()) 
-            {
-              _serialize_varint(tag(), buffer);
-              if(0 < _data)
-              {
-                VAR_UINT_TYPE uint_data = static_cast<VAR_UINT_TYPE>(_data);
-                _serialize_varint(uint_data, buffer);
-              } 
-              else
-              {
-                uint64_t uint_data = static_cast<uint64_t>(_data);
-                _serialize_varint(uint_data, buffer);
-              }
-            }
-            else
-            {
-              result = Result::ERROR_BUFFER_TO_SMALL;
-            }
-          }
-          return result;
-        }
-
-        //! \see Field::deserialize()
-        Result deserialize(MessageBufferInterface& buffer) final
-        {
-          Result result(Result::OK);
-          uint64_t uint_data;
-          if(_deserialize_varint(uint_data, buffer))
-          {
-            _data = static_cast<DATA_TYPE>(uint_data);
-          }
-          else
-          {
-            // TODO create a better error for this case. May be an error from _deserialize_varint().
-            result = Result::ERROR_BUFFER_TO_SMALL;
-          }
-          return result;
-        }
-
-        //! \see Field::clear()
-        void clear() final
-        {
-          _data = DEFAULT_VALUE;
-        }
-        
-        //! \see Field::serialized_data_size()
-        uint32_t serialized_data_size() const final
-        {
-          return serialized_size_varint(static_cast<VAR_UINT_TYPE>(_data));
-        }
-
-      protected:
-
-        //! The actual data.
-        DATA_TYPE _data;
-
-    }; 
-
-
-  } // End of namespace Detail
-
-  /*!
-    Actually define the types to beused in messages. These specify the template for different field 
-    types.
-    \{
-  */
-  typedef Detail::FieldVarInt<int32_t>  int32;
-  typedef Detail::FieldVarInt<int64_t>  int64;
-
-  typedef Detail::FieldVarInt<uint32_t> uint32;
-  typedef Detail::FieldVarInt<uint64_t> uint64;
-  /*! \} */
-
-
-} // End of namespace EmbeddedProto
-
-
-#endif // _FIELD_VARINT_H_

src/MessageNanopbTemplate.h

@@ -1,40 +0,0 @@
-
-#ifndef _MESSAGE_NANOPB_TEMPLATE_H_
-#define _MESSAGE_NANOPB_TEMPLATE_H_
-
-#include <MessageInterface.h>
-
-namespace EmbeddedProto {
-
-template<class NANOPB_STRUCT>
-class MessageNanopbTemplate : public MessageInterface
-{
-public:
-    MessageNanopbTemplate() = default;
-    ~MessageNanopbTemplate() = default;
-
-
-    NANOPB_STRUCT& get() {
-        return data;
-    }
-
-    NANOPB_STRUCT& get() const {
-        return data;
-    }
-
-    NANOPB_STRUCT* operator ->() {
-        return &data;
-    }
-
-protected:
-
-    //! The actual message struct as used by nanopb.
-    NANOPB_STRUCT data;
-
-private:
-
-}
-
-} // End of namespace EmbeddedProto
-
-#endif _MESSAGE_NANOPB_TEMPLATE_H_

test/proto/nested_message.proto

@@ -1,16 +0,0 @@
-
-// This file is used to test the wire formatter class.
-
-syntax = "proto3";
-
-message message_a {
-  int32 x   = 1;
-  float y   = 2;
-  sint64 z  = 3;
-}
-
-message message_b {
-  double a  = 1;
-  double b  = 2;
-  message_a msg_c = 3;
-}

test/proto/state.proto

@@ -1,26 +0,0 @@
-
-syntax = "proto3";
-
-enum State {
-    READY   = 0;
-    SET     = 1;
-    GO      = 2;
-}
-
-message Position {
-    int32 x = 1;
-    int32 y = 2;
-    int32 z = 3;
-}
-
-message Velocity {
-    float u = 1;
-    float v = 2;
-    float w = 3;
-}
-
-message Object {
-    Position pos = 1;
-    Velocity vel = 2;
-    State state  = 3;
-}

test/test_FieldBool.cpp

@@ -1,91 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <FieldBool.h>
-#include <Field.h>
-#include <MessageBufferMock.h>
-
-using ::testing::_;
-using ::testing::InSequence;
-using ::testing::Return;
-using ::testing::SetArgReferee;
-using ::testing::DoAll;
-
-namespace test_EmbeddedAMS_FieldBool
-{
-  TEST(FieldBoolTest, set_get)
-  {
-    EmbeddedProto::boolean a(1);
-
-    // Default value should be false.
-    EXPECT_EQ(false, a.get());
-
-    a.set(true);
-    EXPECT_EQ(true, a.get());
-
-    a = false;
-    EXPECT_EQ(false, a.get());
-  }
-
-  TEST(FieldBoolTest, serialize_buffer_to_small)
-  {
-    EmbeddedProto::boolean a(1);
-    a = true;
-    Mocks::MessageBufferMock buffer; 
-    // The default mock buffer.get_max_size() will return zero, iow to small to fit.
-    EXPECT_EQ(EmbeddedProto::Field::Result::ERROR_BUFFER_TO_SMALL, a.serialize(buffer));
-  }
-
-  TEST(FieldBoolTest, deserialize_buffer_to_small)
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-        
-    EmbeddedProto::boolean a(1);
-    Mocks::MessageBufferMock buffer; 
-    EXPECT_CALL(buffer, get_size()).WillOnce(Return(0));
-    EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_EQ(EmbeddedProto::Field::Result::ERROR_BUFFER_TO_SMALL, a.deserialize(buffer));
-  }
-
-  TEST(FieldBoolTest, serialize_false)
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    EmbeddedProto::boolean a(1);
-    a = false;
-    Mocks::MessageBufferMock buffer; 
-    ON_CALL(buffer, get_max_size()).WillByDefault(Return(2));
-    EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-  }
-
-  TEST(FieldBoolTest, serialize_true)
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    EmbeddedProto::boolean a(1);
-    a = true;
-    Mocks::MessageBufferMock buffer; 
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(2));
-    EXPECT_CALL(buffer, push(0x08)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-  }
-
-  TEST(FieldBoolTest, deserialize_true)
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    EmbeddedProto::boolean a(1);
-    Mocks::MessageBufferMock buffer; 
-    EXPECT_CALL(buffer, get_size()).WillOnce(Return(1));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-    EXPECT_EQ(true, a.get());
-  }
-
-} // End of namespace test_EmbeddedAMS_FieldBool

test/test_FieldEnum.cpp

@@ -1,153 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <FieldEnum.h>
-#include <Field.h>
-#include <MessageBufferMock.h>
-
-using ::testing::_;
-using ::testing::InSequence;
-using ::testing::Return;
-using ::testing::SetArgReferee;
-using ::testing::DoAll;
-
-namespace test_EmbeddedAMS_FieldEnum
-{
-  enum test_enum {
-    ZERO  = 0,
-    ONE   = 1,
-    TWO   = 2,
-    ONEHUNDERTTWENTYSEVEN = 127,
-    ONEHUNDERTTWENTYEIGHT = 128,
-    TWOHUNDERDFIFTYFIVE   = 255,
-    TWOBILLION = 2000000000
-  };
-
-  enum class test_enum_class : uint32_t {
-    I = 0,
-    J = 100000, 
-    K = 1000000000
-  };
-
-  TEST(FieldEnumTest, set_get)
-  {
-    EmbeddedProto::Enumeration<test_enum> a(1);
-
-    // Default value should be the first item.
-    EXPECT_EQ(ZERO, a.get());
-
-    a.set(ONE);
-    EXPECT_EQ(ONE, a.get());
-
-    a = TWOHUNDERDFIFTYFIVE;
-    EXPECT_EQ(TWOHUNDERDFIFTYFIVE, a.get());
-
-
-    EmbeddedProto::Enumeration<test_enum_class> b(2);
-    EXPECT_EQ(test_enum_class::I, b.get());
-
-    b.set(test_enum_class::J);
-    EXPECT_EQ(test_enum_class::J, b.get());
-
-    b = test_enum_class::K;
-    EXPECT_EQ(test_enum_class::K, b.get()); 
-  }
-
-  TEST(FieldEnumTest, serialize_buffer_to_small)
-  {
-    EmbeddedProto::Enumeration<test_enum> a(1);
-    a = TWO;
-    Mocks::MessageBufferMock buffer; 
-    // The default mock buffer.get_max_size() will return zero, iow to small to fit.
-    EXPECT_EQ(EmbeddedProto::Field::Result::ERROR_BUFFER_TO_SMALL, a.serialize(buffer));  }
-
-  TEST(FieldEnumTest, deserialize_buffer_to_small)
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    EmbeddedProto::Enumeration<test_enum> a(1);
-    Mocks::MessageBufferMock buffer; 
-    EXPECT_CALL(buffer, get_size()).WillOnce(Return(0));
-    EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_EQ(EmbeddedProto::Field::Result::ERROR_BUFFER_TO_SMALL, a.deserialize(buffer));
-  }
-
-  TEST(FieldEnumTest, serialize_zero) 
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    EmbeddedProto::Enumeration<test_enum> a(1);
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-  }
-
-  TEST(FieldEnumTest, serialize_one) 
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    EmbeddedProto::Enumeration<test_enum> a(8);
-    a = ONE;
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(2));
-    EXPECT_CALL(buffer, push(0x40)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-  }
-
-  TEST(FieldEnumTest, serialize_two_billion) 
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    EmbeddedProto::Enumeration<test_enum> a(8);
-    a = TWOBILLION;
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(6));
-    EXPECT_CALL(buffer, push(0x40)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x80)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xA8)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xD6)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xB9)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x07)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-  }
-
-  TEST(FieldEnumTest, deserialize_one)
-  {
-    InSequence s;
-
-    EmbeddedProto::Enumeration<test_enum> a(8); // Use a different id to vary.
-    Mocks::MessageBufferMock buffer;
-
-    ON_CALL(buffer, get_size()).WillByDefault(Return(9));
-
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-
-    EXPECT_EQ(ONE, a.get());
-  }
-
-  TEST(FieldEnumTest, deserialize_two_billion)
-  {
-    InSequence s;
-
-    EmbeddedProto::Enumeration<test_enum> a(8); // Use a different id to vary.
-    Mocks::MessageBufferMock buffer;
-
-    ON_CALL(buffer, get_size()).WillByDefault(Return(5));
-
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x80), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xA8), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xD6), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xB9), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x07), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-
-    EXPECT_EQ(TWOBILLION, a.get());
-  }
-
-} // End of namespace test_EmbeddedAMS_FieldEnum

test/test_FieldFixed.cpp

@@ -1,410 +0,0 @@
-
-#include <gtest/gtest.h>
-
-#include <FieldFixed.h>
-#include <Field.h>
-#include <MessageBufferMock.h>
-
-
-using ::testing::_;
-using ::testing::InSequence;
-using ::testing::Return;
-using ::testing::SetArgReferee;
-using ::testing::DoAll;
-
-namespace test_EmbeddedAMS_FieldFixed
-{
-
-  //! The test fixture class for the following tests.
-  class FieldFixedTest : public ::testing::Test 
-  {
-    public:
-      static constexpr uint8_t N_FIELDS = 6;
-
-      FieldFixedTest() :
-        a(1),
-        b(2),
-        c(3),
-        d(4),
-        e(5),
-        f(6),
-        fields{&a, &b, &c, &d, &e, &f}
-      { 
-
-      }
-
-    protected:
-      EmbeddedProto::fixed64 a;
-      EmbeddedProto::sfixed64 b;
-      EmbeddedProto::double64 c;
-
-      EmbeddedProto::fixed32 d;
-      EmbeddedProto::sfixed32 e;
-      EmbeddedProto::float32 f;
-
-      EmbeddedProto::Field* fields[N_FIELDS];
-  };
-
-  TEST_F(FieldFixedTest, set_get)
-  {
-    constexpr double  RANDOM_DOUBLE = 1682.78324;
-    constexpr float   RANDOM_FLOAT = 2472.25241F;
-
-    // Default value should be zero.
-    EXPECT_EQ(0, a.get());
-
-    // Using set
-    a.set(1U);
-    EXPECT_EQ(1U, a.get());
-    
-    // Test the other types
-    EXPECT_EQ(0, b.get());
-    b.set(-1);
-    EXPECT_EQ(-1, b.get());
-
-    EXPECT_EQ(0.0, c.get());
-    c.set(RANDOM_DOUBLE);
-    EXPECT_EQ(RANDOM_DOUBLE, c.get());
-
-    EXPECT_EQ(0, d.get());
-    d.set(1U);
-    EXPECT_EQ(1U, d.get());
-
-    EXPECT_EQ(0, e.get());
-    e.set(-1);
-    EXPECT_EQ(-1, e.get());
-
-    EXPECT_EQ(0.0F, f.get());
-    f.set(RANDOM_FLOAT);
-    EXPECT_EQ(RANDOM_FLOAT, f.get());
-
-  }
-
-  TEST_F(FieldFixedTest, buffer_to_small)
-  {
-    a = 100;
-    Mocks::MessageBufferMock buffer; 
-    // The default mock buffer.get_max_size() will return zero, iow to small to fit.
-    EXPECT_EQ(EmbeddedProto::Field::Result::ERROR_BUFFER_TO_SMALL, a.serialize(buffer));
-
-  }
-
-  TEST_F(FieldFixedTest, serialize_zero)
-  {
-    // In this test we will test if default values are indeed not serialized.
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    for(auto* field : fields) 
-    {
-        EXPECT_EQ(EmbeddedProto::Field::Result::OK, field->serialize(buffer));
-    }
-
-  }
-
-
-  TEST_F(FieldFixedTest, serialize_one)
-  {
-    // In this test we will test if the value one is serialize correctly for the fixed fields.
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    a = 1U;
-    b = 1;
-    c = 1.0;
-
-    d = 1U;
-    e = 1;
-    f = 1.0F;
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x09)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(7).WillRepeatedly(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x11)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(7).WillRepeatedly(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x19)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(6).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0xF0)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x3F)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x25)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(3).WillRepeatedly(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x2D)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(3).WillRepeatedly(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, e.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x35)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(2).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x80)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x3F)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, f.serialize(buffer));
-
-  }
-
-  TEST_F(FieldFixedTest, serialize_max)
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    a = std::numeric_limits<uint64_t>::max();
-    b = std::numeric_limits<int64_t>::max();
-    c = std::numeric_limits<double>::max();
-
-    d = std::numeric_limits<uint32_t>::max();
-    e = std::numeric_limits<int32_t>::max();
-    f = std::numeric_limits<float>::max();
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x09)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(8).WillRepeatedly(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x11)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(7).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x7F)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x19)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(6).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0xEF)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x7F)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x25)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(4).WillRepeatedly(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x2D)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(3).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x7F)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, e.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x35)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(2).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x7F)).Times(2).WillRepeatedly(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, f.serialize(buffer));
-
-  }
-
-  TEST_F(FieldFixedTest, serialize_min)
-  {
-    // In this test we will test if the value minimum or lowest is serialize correctly for the fixed 
-    // fields.
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    a = std::numeric_limits<uint64_t>::min();
-    b = std::numeric_limits<int64_t>::min();
-    c = std::numeric_limits<double>::lowest();
-
-    d = std::numeric_limits<uint32_t>::min();
-    e = std::numeric_limits<int32_t>::min();
-    f = std::numeric_limits<float>::lowest();
-
-    //EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x11)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(7).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x80)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(9));
-    EXPECT_CALL(buffer, push(0x19)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(6).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0xEF)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.serialize(buffer));
-
-    //EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x2D)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x00)).Times(3).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x80)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, e.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(5));
-    EXPECT_CALL(buffer, push(0x35)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(2).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x7F)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, f.serialize(buffer));
-
-  }
-
-
-  TEST_F(FieldFixedTest, deserialize_one)
-  {
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-
-    ON_CALL(buffer, get_size()).WillByDefault(Return(9));
-
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(7).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-    EXPECT_EQ(1U, a.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(7).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.deserialize(buffer));
-    EXPECT_EQ(1, b.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(6).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true))); 
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xF0), Return(true)));   
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x3F), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.deserialize(buffer));
-    EXPECT_EQ(1.0, c.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(3).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.deserialize(buffer));
-    EXPECT_EQ(1U, d.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(3).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, e.deserialize(buffer));
-    EXPECT_EQ(1, e.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(2).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x80), Return(true)));    
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x3F), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, f.deserialize(buffer));
-    EXPECT_EQ(1.0F, f.get());
-
-    /* 
-      0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-      0x11, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-      0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, 
-
-      0x25, 0x01, 0x00, 0x00, 0x00, 
-      0x2D, 0x01, 0x00, 0x00, 0x00, 
-      0x35, 0x00, 0x00, 0x80, 0x3F 
-    */
-  }
-
-
-  TEST_F(FieldFixedTest, deserialize_max)
-  {
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-
-    ON_CALL(buffer, get_size()).WillByDefault(Return(8));
-
-    EXPECT_CALL(buffer, pop(_)).Times(8).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<uint64_t>::max(), a.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(7).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x7F), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<int64_t>::max(), b.get());
-    
-    EXPECT_CALL(buffer, pop(_)).Times(6).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true))); 
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xEF), Return(true)));   
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x7F), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<double>::max(), c.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(4).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<uint32_t>::max(), d.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(3).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x7F), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, e.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<int32_t>::max(), e.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(2).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(2).WillRepeatedly(DoAll(SetArgReferee<0>(0x7F), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, f.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<float>::max(), f.get());
-
-    /*
-      0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-      0x11, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 
-      0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7F, 
-
-      0x25, 0xFF, 0xFF, 0xFF, 0xFF, 
-      0x2D, 0xFF, 0xFF, 0xFF, 0x7F, 
-      0x35, 0xFF, 0xFF, 0x7F, 0x7F
-    */
-  }
-
-  TEST_F(FieldFixedTest, deserialize_min) 
-  {
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-
-    ON_CALL(buffer, get_size()).WillByDefault(Return(8));
-
-    EXPECT_CALL(buffer, pop(_)).Times(7).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x80), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<int64_t>::min(), b.get());
-    
-    EXPECT_CALL(buffer, pop(_)).Times(6).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true))); 
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xEF), Return(true)));   
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.deserialize(buffer));
-    double dans = std::numeric_limits<double>::lowest();
-    EXPECT_EQ(dans, c.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(3).WillRepeatedly(DoAll(SetArgReferee<0>(0x00), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x80), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, e.deserialize(buffer));
-    EXPECT_EQ(std::numeric_limits<int32_t>::min(), e.get());
-
-    EXPECT_CALL(buffer, pop(_)).Times(2).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x7F), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, f.deserialize(buffer));
-    float fans = std::numeric_limits<float>::lowest();
-    EXPECT_EQ(fans, f.get());
-
-    /*
-      b 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 
-      c 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xFF, 
-
-      e 0x2D, 0x00, 0x00, 0x00, 0x80, 
-      f 0x35, 0xFF, 0xFF, 0x7F, 0xFF
-    */
-  }
-
-} // End of namespace test_EmbeddedAMS_Fields

test/test_FieldVarInt.cpp

@@ -1,288 +0,0 @@
-
-#include <gtest/gtest.h>
-
-#include <FieldVarInt.h>
-#include <Field.h>
-#include <MessageBufferMock.h>
-
-
-using ::testing::_;
-using ::testing::InSequence;
-using ::testing::Return;
-using ::testing::SetArgReferee;
-using ::testing::DoAll;
-
-namespace test_EmbeddedAMS_FieldVarInt
-{
-
-  //! The test fixture class for the following tests.
-  class FieldVarIntTest : public ::testing::Test 
-  {
-    public:
-      static constexpr uint8_t N_FIELDS = 4;
-
-      FieldVarIntTest() :
-        a(1),
-        b(2),
-        c(3),
-        d(4),
-        fields{&a, &b, &c, &d}
-      { 
-
-      }
-
-    protected:
-      EmbeddedProto::int32 a;
-      EmbeddedProto::int64 b;
-      EmbeddedProto::uint32 c;
-      EmbeddedProto::uint64 d;
-
-      EmbeddedProto::Field* fields[N_FIELDS];
-  };
-
-  TEST_F(FieldVarIntTest, set_get)
-  {
-
-    // Default value should be zero.
-    EXPECT_EQ(0, a.get());
-
-    // Using set
-    a.set(-1);
-    EXPECT_EQ(-1, a.get());
-    
-    // Test the other types
-    EXPECT_EQ(0, b.get());
-    b.set(-1);
-    EXPECT_EQ(-1, b.get());
-
-    EXPECT_EQ(0, c.get());
-    c.set(1U);
-    EXPECT_EQ(1U, c.get());
-
-    EXPECT_EQ(0, d.get());
-    d.set(1U);
-    EXPECT_EQ(1U, d.get());
-
-  }
-
-  TEST_F(FieldVarIntTest, buffer_to_small)
-  {
-    a = 100;
-    Mocks::MessageBufferMock buffer; 
-    // The default mock buffer.get_max_size() will return zero, iow to small to fit.
-    EXPECT_EQ(EmbeddedProto::Field::Result::ERROR_BUFFER_TO_SMALL, a.serialize(buffer));
-
-  }
-
-  TEST_F(FieldVarIntTest, serialize_zero)
-  {
-    // In this test we will test if default values are indeed not serialized.
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_)).Times(0);
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    for(auto* field : fields) 
-    {
-        EXPECT_EQ(EmbeddedProto::Field::Result::OK, field->serialize(buffer));
-    }
-
-  }
-
-
-  TEST_F(FieldVarIntTest, serialize_one)
-  {
-    // In this test we will test if the value one is serialize correctly for the fixed fields.
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    a = 1;
-    b = 1;
-    c = 1U;
-    d = 1U;
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(2));
-    EXPECT_CALL(buffer, push(0x08)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(2));
-    EXPECT_CALL(buffer, push(0x10)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(2));
-    EXPECT_CALL(buffer, push(0x18)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(2));
-    EXPECT_CALL(buffer, push(0x20)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.serialize(buffer));
-
-
-  }
-
-  TEST_F(FieldVarIntTest, serialize_max)
-  {
-    // In this test we will test if the maximum is serialize correctly for the fixed fields.
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    a = std::numeric_limits<int32_t>::max();
-    b = std::numeric_limits<int64_t>::max();
-    c = std::numeric_limits<uint32_t>::max();
-    d = std::numeric_limits<uint64_t>::max();
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(6));
-    EXPECT_CALL(buffer, push(0x08)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(4).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x07)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(10));
-    EXPECT_CALL(buffer, push(0x10)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(8).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x7F)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(6));
-    EXPECT_CALL(buffer, push(0x18)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(4).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x0F)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(11));
-    EXPECT_CALL(buffer, push(0x20)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(9).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.serialize(buffer));
-  }
-
-  TEST_F(FieldVarIntTest, serialize_min)
-  {
-    // In this test we will test if the value minimum or lowest is serialize correctly for the fixed 
-    // fields.
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-    EXPECT_CALL(buffer, push(_,_)).Times(0);
-
-    a = std::numeric_limits<int32_t>::min();
-    b = std::numeric_limits<int64_t>::min();
-    c = std::numeric_limits<uint32_t>::min();
-    d = std::numeric_limits<uint64_t>::min();
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(11));
-    EXPECT_CALL(buffer, push(0x08)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x80)).Times(4).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0xF8)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0xFF)).Times(4).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.serialize(buffer));
-
-    EXPECT_CALL(buffer, get_max_size()).WillOnce(Return(11));
-    EXPECT_CALL(buffer, push(0x10)).Times(1).WillOnce(Return(true));
-    EXPECT_CALL(buffer, push(0x80)).Times(9).WillRepeatedly(Return(true));
-    EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
-
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.serialize(buffer));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.serialize(buffer));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.serialize(buffer));
-  }
-
-
-  TEST_F(FieldVarIntTest, deserialize_one)
-  {
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-
-    ON_CALL(buffer, get_size()).WillByDefault(Return(9));
-
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.deserialize(buffer));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.deserialize(buffer));
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.deserialize(buffer));
-
-    EXPECT_EQ(1, a.get());
-    EXPECT_EQ(1, b.get());
-    EXPECT_EQ(1U, c.get());
-    EXPECT_EQ(1U, d.get());    
-  }
-
-  TEST_F(FieldVarIntTest, deserialize_max)
-  {
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-
-    EXPECT_CALL(buffer, pop(_)).Times(4).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x07), Return(true)));
-
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-
-    EXPECT_CALL(buffer, pop(_)).Times(8).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x7F), Return(true)));
-    
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.deserialize(buffer));
-
-    EXPECT_CALL(buffer, pop(_)).Times(4).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x0F), Return(true)));
-    
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, c.deserialize(buffer));
-
-    EXPECT_CALL(buffer, pop(_)).Times(9).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, d.deserialize(buffer));
-
-
-    EXPECT_EQ(std::numeric_limits<int32_t>::max(), a.get());
-    EXPECT_EQ(std::numeric_limits<int64_t>::max(), b.get());
-    EXPECT_EQ(std::numeric_limits<uint32_t>::max(), c.get());
-    EXPECT_EQ(std::numeric_limits<uint64_t>::max(), d.get());    
-
-/*
-    0xFF, 0xFF, 0xFF, 0xFF, 0x07, 
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 
-    0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01
-*/
-  }
-
-  TEST_F(FieldVarIntTest, deserialize_min)
-  {
-    InSequence s;
-
-    Mocks::MessageBufferMock buffer;
-
-    EXPECT_CALL(buffer, pop(_)).Times(4).WillRepeatedly(DoAll(SetArgReferee<0>(0x80), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0xF8), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(4).WillRepeatedly(DoAll(SetArgReferee<0>(0xFF), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, a.deserialize(buffer));
-
-    EXPECT_CALL(buffer, pop(_)).Times(9).WillRepeatedly(DoAll(SetArgReferee<0>(0x80), Return(true)));
-    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(0x01), Return(true)));
-    
-    EXPECT_EQ(EmbeddedProto::Field::Result::OK, b.deserialize(buffer));
-
-    EXPECT_EQ(std::numeric_limits<int32_t>::min(), a.get());
-    EXPECT_EQ(std::numeric_limits<int64_t>::min(), b.get());
-    EXPECT_EQ(std::numeric_limits<uint32_t>::min(), c.get());
-    EXPECT_EQ(std::numeric_limits<uint64_t>::min(), d.get());
-  }
-
-} // End of namespace test_EmbeddedAMS_Fields