When partially deserializing properly packed and unpacked repeated fields.

Skip packed fields if the number of bytes is zero.
At least allocated an element for unpacked fields when the number of bytes for that one unpacked field is zero.

Author: BartHertog

src/RepeatedField.h

@@ -346,7 +346,8 @@ namespace EmbeddedProto
           return_value = WireFormatter::DeserializeVarint(buffer, n_bytes_to_include_in_section);
         }
 
-        if(Error::NO_ERRORS == return_value) 
+        // If there are no bytes in the array do not start deserializing data.
+        if((Error::NO_ERRORS == return_value) && (0 < n_bytes_to_include_in_section))
         {
           ReadBufferSection bufferSection(buffer, n_bytes_to_include_in_section);
           DATA_TYPE x;
@@ -404,20 +405,26 @@ namespace EmbeddedProto
 
             if(Error::NO_ERRORS == return_value) 
             {
-              ReadBufferSection bufferSection(buffer, n_bytes_to_include_in_section);
+              // Even if the number of bytes is zero we should allocate the element in the array.
+              auto& element = this->get(index);
 
-              // See how many bytes we will now process from the buffer and thus how many bytes are left for the next iteration.
-              n_bytes_to_include_in_section -= bufferSection.get_size();
+              if(0 < n_bytes_to_include_in_section)
+              {
+                ReadBufferSection bufferSection(buffer, n_bytes_to_include_in_section);
 
-              return_value = this->get(index).deserialize(bufferSection);
+                // See how many bytes we will now process from the buffer and thus how many bytes are left for the next iteration.
+                n_bytes_to_include_in_section -= bufferSection.get_size();
 
-              n_bytes_to_include_in_section += bufferSection.get_size();
+                return_value = element.deserialize(bufferSection);
 
-              // In case we have bytes we still need to receive set the end of buffer return value. 
-              // The return value of deserialize has priority.
-              if((::EmbeddedProto::Error::NO_ERRORS == return_value) && (0 < n_bytes_to_include_in_section))
-              {
-                return_value = ::EmbeddedProto::Error::END_OF_BUFFER;
+                n_bytes_to_include_in_section += bufferSection.get_size();
+
+                // In case we have bytes we still need to receive set the end of buffer return value. 
+                // The return value of deserialize has priority.
+                if((::EmbeddedProto::Error::NO_ERRORS == return_value) && (0 < n_bytes_to_include_in_section))
+                {
+                  return_value = ::EmbeddedProto::Error::END_OF_BUFFER;
+                }
               }
             }
           }

test/test_RepeatedFieldMessage.cpp

@@ -359,23 +359,28 @@ TEST(RepeatedFieldMessage, serialize_fault_buffer_full)
 
 TEST(RepeatedFieldMessage, deserialize_empty_array) 
 {
+  InSequence s;
   repeated_fields<Y_SIZE> msg;
 
   Mocks::ReadBufferMock buffer;
-  EXPECT_CALL(buffer, pop(_)).WillRepeatedly(Return(false));
-  EXPECT_CALL(buffer, get_size()).WillRepeatedly(Return(0));
+  EXPECT_CALL(buffer, peek(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(0x12), Return(true))); // Tag of y
+  EXPECT_CALL(buffer, peek(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(0x00), Return(true)));// Size of y = 0
+  EXPECT_CALL(buffer, peek(_, _)).Times(1).WillOnce(Return(false));
 
   EXPECT_EQ(::EmbeddedProto::Error::NO_ERRORS, msg.deserialize(buffer));
 
 }
 
 TEST(RepeatedFieldMessage, deserialize_empty_message_array) 
 {
+  InSequence s;
+
   repeated_message<Y_SIZE> msg;
 
   Mocks::ReadBufferMock buffer;
-  EXPECT_CALL(buffer, pop(_)).WillRepeatedly(Return(false));
-  EXPECT_CALL(buffer, get_size()).WillRepeatedly(Return(0));
+  EXPECT_CALL(buffer, peek(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(0x12), Return(true)));// Tag of b
+  EXPECT_CALL(buffer, peek(_, _)).Times(1).WillOnce(DoAll(SetArgReferee<1>(0x00), Return(true)));// Size of b = 0
+  EXPECT_CALL(buffer, peek(_, _)).Times(1).WillOnce(Return(false));
 
   EXPECT_EQ(::EmbeddedProto::Error::NO_ERRORS, msg.deserialize(buffer));
 }
@@ -420,11 +425,13 @@ TEST(RepeatedFieldMessage, deserialize_one_partial)
 
   EmbeddedProto::ReadBufferFixedSize<SIZE> buffer({  
                                     0x08, 0x01, // x tag and value
-                                    0x12, 0x03}); // y tag and size.
-                                    
+                                    0x12}); // y tag 
+
+  buffer.push(0x03); //y size                                    
 
   EXPECT_EQ(::EmbeddedProto::Error::END_OF_BUFFER, msg.deserialize(buffer));
-                                 
+
+          
   buffer.push(0x01);  // start of y data.                                
   buffer.push(0x01);
   buffer.push(0x01);                                
@@ -455,7 +462,7 @@ TEST(RepeatedFieldMessage, deserialize_one_message_array)
   ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
 
   std::array<uint8_t, SIZE> referee = { 0x08, 0x01, // x
-                                        0x12, 0x00, 0x12, 0x04, 0x08, 0x01, 0x10, 0x01, 0x12, 0x00, // y
+                                        0x12, 0x00, 0x12, 0x04, 0x08, 0x01, 0x10, 0x01, 0x12, 0x00, // b
                                         0x18, 0x01}; // z 
 
   for(auto r: referee) 
@@ -491,11 +498,11 @@ TEST(RepeatedFieldMessage, deserialize_mixed_message_array)
 
   ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
 
-  std::array<uint8_t, SIZE> referee = { 0x12, 0x00, // y[0]
+  std::array<uint8_t, SIZE> referee = { 0x12, 0x00, // b[0]
                                         0x08, 0x01, // x
-                                        0x12, 0x04, 0x08, 0x01, 0x10, 0x01, // y[1]
+                                        0x12, 0x04, 0x08, 0x01, 0x10, 0x01, // b[1]
                                         0x18, 0x01, // z
-                                        0x12, 0x00, }; // y[2] 
+                                        0x12, 0x00, }; // b[2] 
 
   for(auto r: referee) 
   {