Tests for deserializing repeated messages.

src/RepeatedField.h

@@ -20,6 +20,9 @@ namespace EmbeddedProto
   {
     static_assert(std::is_base_of<::EmbeddedProto::Field, DATA_TYPE>::value, "A Field can only be used as template paramter.");
 
+    //! Check how this field shoeld be serialized, packed or not.
+    static constexpr bool PACKED = !std::is_base_of<MessageInterface, DATA_TYPE>::value;
+
     public:
 
       RepeatedField() = default;
@@ -102,9 +105,6 @@ namespace EmbeddedProto
       {
         bool result = true;
 
-        //! Check how this field shoeld be serialized, packed or not.
-        static constexpr bool PACKED = !std::is_base_of<MessageInterface, DATA_TYPE>::value;
-
         if(PACKED)
         {
           const uint32_t size_x = this->serialized_size_packed(field_number);
@@ -138,12 +138,28 @@ namespace EmbeddedProto
       */
       bool deserialize(::EmbeddedProto::ReadBufferInterface& buffer) final
       {
-        this->clear();
-        DATA_TYPE x;
         bool result = true;
-        while(result && x.deserialize(buffer)) 
+        if(PACKED)
+        {              
+          uint32_t size;
+          result = ::EmbeddedProto::WireFormatter::DeserializeVarint(buffer, size);
+          ::EmbeddedProto::ReadBufferSection bufferSection(buffer, size);
+          DATA_TYPE x;
+          while(result && x.deserialize(bufferSection)) 
+          {
+            result = this->add(x);
+          }
+        }
+        else 
         {
-          result = this->add(x);
+          uint32_t size;
+          result = ::EmbeddedProto::WireFormatter::DeserializeVarint(buffer, size);
+          ::EmbeddedProto::ReadBufferSection bufferSection(buffer, size);
+          DATA_TYPE x;
+          if(result && x.deserialize(bufferSection))
+          {
+            result = this->add(x);
+          }
         }
         return result;
       }

test/test_RepeatedFieldMessage.cpp

@@ -129,6 +129,44 @@ TEST(RepeatedFieldMessage, serialize_array_zero_one_zero)
   EXPECT_TRUE(msg.serialize(buffer));
 }
 
+TEST(RepeatedFieldMessage, serialize_array_zero_one_zero_messages)
+{ 
+  InSequence s;
+  
+  Mocks::WriteBufferMock buffer;
+  repeated_message<Y_SIZE> msg;
+
+  repeated_nested_message rnm;
+  
+  rnm.set_u(0);
+  rnm.set_v(0);
+  msg.add_y(rnm);
+
+  rnm.set_u(1);
+  rnm.set_v(1);
+  msg.add_y(rnm);
+  
+  rnm.set_u(0);
+  rnm.set_v(0);
+  msg.add_y(rnm);
+
+  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(10));
+
+  EXPECT_CALL(buffer, push(0x12)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x00)).Times(1).WillOnce(Return(true));
+
+  EXPECT_CALL(buffer, push(0x12)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x04)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x08)).Times(1).WillOnce(Return(true)); 
+  EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x10)).Times(1).WillOnce(Return(true)); 
+  EXPECT_CALL(buffer, push(0x01)).Times(1).WillOnce(Return(true));
+
+  EXPECT_CALL(buffer, push(0x12)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x00)).Times(1).WillOnce(Return(true));
+
+  EXPECT_TRUE(msg.serialize(buffer));
+}
 
 TEST(RepeatedFieldMessage, serialize_array_one)
 {
@@ -241,7 +279,7 @@ TEST(RepeatedFieldMessage, serialize_max)
   EXPECT_TRUE(msg.serialize(buffer));
 }
 
-TEST(RepeatedFieldMessage, deserialize_empty) 
+TEST(RepeatedFieldMessage, deserialize_empty_array) 
 {
   repeated_fields<Y_SIZE> msg;
 
@@ -253,6 +291,17 @@ TEST(RepeatedFieldMessage, deserialize_empty)
 
 }
 
+TEST(RepeatedFieldMessage, deserialize_empty_message_array) 
+{
+  repeated_message<Y_SIZE> msg;
+
+  Mocks::ReadBufferMock buffer;
+  EXPECT_CALL(buffer, pop(_)).WillRepeatedly(Return(false));
+  EXPECT_CALL(buffer, get_size()).WillRepeatedly(Return(0));
+
+  EXPECT_TRUE(msg.deserialize(buffer));
+}
+
 TEST(RepeatedFieldMessage, deserialize_one) 
 {
   InSequence s;
@@ -281,6 +330,71 @@ TEST(RepeatedFieldMessage, deserialize_one)
 
 }
 
+TEST(RepeatedFieldMessage, deserialize_one_message_array) 
+{
+  InSequence s;
+
+  repeated_message<Y_SIZE> msg;
+  Mocks::ReadBufferMock buffer;
+
+  uint8_t referee[] = {0x08, 0x01, // x
+                       0x12, 0x00, 0x12, 0x04, 0x08, 0x01, 0x10, 0x01, 0x12, 0x00, // y
+                       0x18, 0x01}; // z 
+
+  for(auto r: referee) 
+  {
+    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(r), Return(true)));
+  }
+  EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(Return(false));
+
+  EXPECT_TRUE(msg.deserialize(buffer));
+
+  EXPECT_EQ(1, msg.get_x());
+  EXPECT_EQ(3, msg.get_y().get_length());
+  EXPECT_EQ(0, msg.y(0).u());
+  EXPECT_EQ(0, msg.y(0).v());
+  EXPECT_EQ(1, msg.y(1).u());
+  EXPECT_EQ(1, msg.y(1).v());
+  EXPECT_EQ(0, msg.y(2).u());
+  EXPECT_EQ(0, msg.y(2).v());
+  EXPECT_EQ(1, msg.get_z());
+}
+
+TEST(RepeatedFieldMessage, deserialize_mixed_message_array) 
+{
+  // I should be possible to read in the non packed data mixed with other fields. All elements 
+  // should be added to the array.
+
+  InSequence s;
+
+  repeated_message<Y_SIZE> msg;
+  Mocks::ReadBufferMock buffer;
+
+  uint8_t referee[] = {0x12, 0x00, // y[0]
+                       0x08, 0x01, // x
+                       0x12, 0x04, 0x08, 0x01, 0x10, 0x01, // y[1]
+                       0x18, 0x01, // z
+                       0x12, 0x00, }; // y[2] 
+
+  for(auto r: referee) 
+  {
+    EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(DoAll(SetArgReferee<0>(r), Return(true)));
+  }
+  EXPECT_CALL(buffer, pop(_)).Times(1).WillOnce(Return(false));
+
+  EXPECT_TRUE(msg.deserialize(buffer));
+
+  EXPECT_EQ(1, msg.get_x());
+  EXPECT_EQ(3, msg.get_y().get_length());
+  EXPECT_EQ(0, msg.y(0).u());
+  EXPECT_EQ(0, msg.y(0).v());
+  EXPECT_EQ(1, msg.y(1).u());
+  EXPECT_EQ(1, msg.y(1).v());
+  EXPECT_EQ(0, msg.y(2).u());
+  EXPECT_EQ(0, msg.y(2).v());
+  EXPECT_EQ(1, msg.get_z());
+}
+
 TEST(RepeatedFieldMessage, deserialize_max) 
 {
   InSequence s;

test_data.py

@@ -135,13 +135,16 @@ def test_repeated_fields():
 def test_repeated_message():
     msg = rf.repeated_message()
 
-    msg.x = 1
+    msg.x = 0
     for i in range(3):
         nmsg = msg.y.add()
         nmsg.u = 0
         nmsg.v = 0
     msg.z = 0
 
+    msg.y[1].u = 1
+    msg.y[1].v = 1
+
     str = ""
     msg_str = msg.SerializeToString()
     print(len(msg_str))
@@ -152,6 +155,6 @@ def test_repeated_message():
     print(str)
     print()
 
-test_repeated_fields()
+#test_repeated_fields()
 test_repeated_message()
-test_nested_message()
+#test_nested_message()