Got the nested message test working with repeated fields in side.

generator/support/Field.py

@@ -270,7 +270,7 @@ class FieldBytes(Field):
         return True
 
     def render_get_set(self, jinja_env):
-        return self.render("FieldBytes_Bytes.h", jinja_environment=jinja_env)
+        return self.render("FieldBytes_GetSet.h", jinja_environment=jinja_env)
 
     def render_serialize(self, jinja_env):
         return self.render("FieldRepeated_Serialize.h", jinja_environment=jinja_env)
@@ -432,7 +432,7 @@ class FieldRepeated(Field):
         self.template_param_str = self.variable_name + "LENGTH"
 
     def get_wire_type_str(self):
-        return self.actual_type.get_wire_type_str()
+        return "LENGTH_DELIMITED"
 
     def get_type(self):
         return "::EmbeddedProto::RepeatedFieldFixedSize<" + self.actual_type.get_type() + ", " + \
@@ -442,6 +442,10 @@ class FieldRepeated(Field):
         return "::EmbeddedProto::RepeatedFieldFixedSize<" + self.actual_type.get_short_type() + ", " + \
                self.template_param_str + ">"
 
+    # As this is a repeated field we need a function to get the type we are repeating.
+    def get_base_type(self):
+        return self.actual_type.get_type()
+
     def get_template_parameters(self):
         result = [{"name": self.template_param_str, "type": "uint32_t"}]
         result.extend(self.actual_type.get_template_parameters())

generator/templates/FieldRepeated_GetSet.h

@@ -27,8 +27,11 @@ Postal address:
   1066 VH, Amsterdam
   the Netherlands
 #}
+inline const {{field.get_base_type()}}& {{field.get_name()}}(uint32_t index) const { return {{field.get_variable_name()}}[index]; }
 inline void clear_{{field.get_name()}}() { {{field.get_variable_name()}}.clear(); }
-inline void set_{{field.get_name()}}(const {{field.get_type()}}& value) { {{field.get_variable_name()}} = value; }
-inline void set_{{field.get_name()}}(const {{field.get_type()}}&& value) { {{field.get_variable_name()}} = value; }
+inline void set_{{field.get_name()}}(uint32_t index, const {{field.get_base_type()}}& value) { {{field.get_variable_name()}}.set(index, value); }
+inline void set_{{field.get_name()}}(uint32_t index, const {{field.get_base_type()}}&& value) { {{field.get_variable_name()}}.set(index, value); }
+inline void set_{{field.get_name()}}(const {{field.get_type()}}& values) { {{field.get_variable_name()}} = values; }
+inline void add_{{field.get_name()}}(const {{field.get_base_type()}}& value) { {{field.get_variable_name()}}.add(value); }
 inline {{field.get_type()}}& mutable_{{field.get_name()}}() { return {{field.get_variable_name()}}; }
 inline const {{field.get_type()}}& get_{{field.get_name()}}() const { return {{field.get_variable_name()}}; }

generator/templates/TypeDefMsg.h

@@ -124,7 +124,7 @@ class {{ typedef.get_name() }} final: public ::EmbeddedProto::MessageInterface
           }
 
           {% endfor %}
-{#        {% for oneof in typedef.oneofs %}
+          {% for oneof in typedef.oneofs %}
           {% for field in oneof.fields() %}
           case static_cast<uint32_t>(id::{{field.get_variable_id_name()}}):
           {
@@ -133,7 +133,7 @@ class {{ typedef.get_name() }} final: public ::EmbeddedProto::MessageInterface
           }
 
           {% endfor %}
-          {% endfor %} #}
+          {% endfor %}
           default:
             break;
         }

test/test_NestedMessage.cpp

@@ -49,11 +49,13 @@ using ::testing::SetArgReferee;
 namespace test_EmbeddedAMS_NestedMessage
 {
 
+constexpr uint32_t SIZE_MSG_A = 3;
+
 TEST(NestedMessage, serialize_zero) 
 {
   // Test if a unset message results in zero bytes in the buffer.
 
-  ::message_b msg;
+  ::message_b<SIZE_MSG_A> msg;
   Mocks::WriteBufferMock buffer;
   EXPECT_CALL(buffer, push(_)).Times(0);
   EXPECT_CALL(buffer, push(_,_)).Times(0);
@@ -68,14 +70,14 @@ TEST(NestedMessage, serialize_one)
 {
   InSequence s;
 
-  ::message_b msg;
+  ::message_b<SIZE_MSG_A> msg;
   Mocks::WriteBufferMock buffer;
-  ON_CALL(buffer, get_size()).WillByDefault(Return(9));
+  ON_CALL(buffer, get_size()).WillByDefault(Return(25));
 
 
   // Test if a nested message can be serialized with values set to one.
   msg.set_u(1.0F);
-  msg.mutable_nested_a().set_x(1);
+  msg.mutable_nested_a().add_x(1);
   msg.mutable_nested_a().set_y(1.0F);
   msg.mutable_nested_a().set_z(1);
   msg.set_v(1);
@@ -87,10 +89,16 @@ TEST(NestedMessage, serialize_one)
   }
 
   // When called the buffer will have enough space for the message
-  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(10));
+  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(11));
+
+  // tag and size of nested a
+  EXPECT_CALL(buffer, push(0x12)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x0A)).Times(1).WillOnce(Return(true));
 
-  uint8_t expected_a[] = {0x12, 0x09, // tag and size of nested a
-                          0x08, 0x01, // x
+  // The next call is for the repeated field x.
+  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(9));
+
+  uint8_t expected_a[] = {0x0A, 0x01, 0x01, // x
                           0x15, 0x00, 0x00, 0x80, 0x3f, // y
                           0x18, 0x02, // z
                           0x18, 0x01};// And back to the parent message with field v.
@@ -102,34 +110,41 @@ TEST(NestedMessage, serialize_one)
 
   EXPECT_EQ(::EmbeddedProto::Error::NO_ERRORS, msg.serialize(buffer));
 
-  EXPECT_EQ(22, msg.serialized_size());
+  EXPECT_EQ(23, msg.serialized_size());
 }
 
 TEST(NestedMessage, serialize_max) 
 {
   InSequence s;
 
-  ::message_b msg;
+  ::message_b<SIZE_MSG_A> msg;
   Mocks::WriteBufferMock buffer;
 
   // Test if a nested message can be serialized with values set to one.
   msg.set_u(std::numeric_limits<double>::max());
-  msg.mutable_nested_a().set_x(std::numeric_limits<int32_t>::max());
+  msg.mutable_nested_a().add_x(std::numeric_limits<int32_t>::max());
   msg.mutable_nested_a().set_y(std::numeric_limits<float>::max());
   msg.mutable_nested_a().set_z(std::numeric_limits<int64_t>::max());
   msg.set_v(std::numeric_limits<int32_t>::max());
 
   uint8_t expected_b[] = {0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7F}; // u
 
+
   for(auto e : expected_b) {
     EXPECT_CALL(buffer, push(e)).Times(1).WillOnce(Return(true));
   }
 
   // When called the buffer will have enough space for the message
-  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(23));
+  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(31));
 
-  uint8_t expected_a[] = {0x12, 0x16, // tag and size of nested a
-                          0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
+  // tag and size of nested a
+  EXPECT_CALL(buffer, push(0x12)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x17)).Times(1).WillOnce(Return(true));
+
+  // The next call is for the repeated field x.
+  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(11));
+
+  uint8_t expected_a[] = {0x0A, 0x05, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
                           0x15, 0xFF, 0xFF, 0x7F, 0x7F, // y
                           0x18, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, // z
                           // And back to the parent message with field v.
@@ -141,26 +156,26 @@ TEST(NestedMessage, serialize_max)
 
   EXPECT_EQ(::EmbeddedProto::Error::NO_ERRORS, msg.serialize(buffer));
 
-  EXPECT_EQ(39, msg.serialized_size());
+  EXPECT_EQ(40, msg.serialized_size());
 }
 
 TEST(NestedMessage, serialize_nested_in_nested_max) 
 {
   InSequence s;
 
-  ::message_c msg;
+  ::message_c<SIZE_MSG_A> msg;
   Mocks::WriteBufferMock buffer;
 
   // Test if a nested message in a nested message with some data works.
   msg.mutable_nested_b().set_u(std::numeric_limits<double>::max());
-  msg.mutable_nested_b().mutable_nested_a().set_x(std::numeric_limits<int32_t>::max());
+  msg.mutable_nested_b().mutable_nested_a().add_x(std::numeric_limits<int32_t>::max());
   msg.mutable_nested_b().mutable_nested_a().set_y(std::numeric_limits<float>::max());
   msg.mutable_nested_b().mutable_nested_a().set_z(std::numeric_limits<int64_t>::max());
   msg.mutable_nested_b().set_v(std::numeric_limits<int32_t>::max());
 
   EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(42));
 
-  uint8_t expected_b[] = {0x0A, 0x27, // tag and size of nested b
+  uint8_t expected_b[] = {0x0A, 0x28, // tag and size of nested b
                           0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7F}; // u
 
   for(auto e : expected_b) {
@@ -168,10 +183,16 @@ TEST(NestedMessage, serialize_nested_in_nested_max)
   }
 
   // When called the buffer will have enough space for the message
-  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(23));
+  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(31));
+
+  // tag and size of nested a
+  EXPECT_CALL(buffer, push(0x12)).Times(1).WillOnce(Return(true));
+  EXPECT_CALL(buffer, push(0x17)).Times(1).WillOnce(Return(true));
+
+  // The next call is for the repeated field x.
+  EXPECT_CALL(buffer, get_available_size()).Times(1).WillOnce(Return(11));
 
-  uint8_t expected_a[] = {0x12, 0x16, // tag and size of nested a
-                          0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
+  uint8_t expected_a[] = {0x0A, 0x05, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
                           0x15, 0xFF, 0xFF, 0x7F, 0x7F, // y
                           0x18, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, // z
                           // And back to the parent message with field v.
@@ -188,19 +209,19 @@ TEST(NestedMessage, deserialize_one)
 {
   InSequence s;
 
-  ::message_b msg;
+  ::message_b<SIZE_MSG_A> msg;
   Mocks::ReadBufferMock buffer;
 
 
-  static constexpr uint32_t SIZE = 22;
+  static constexpr uint32_t SIZE = 23;
 
   ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
 
   // Test if a nested message can be deserialized with values set to one.
 
   uint8_t referee[SIZE] = { 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, // u
-                            0x12, 0x09, // tag and size of nested a
-                            0x08, 0x01, // x
+                            0x12, 0x0A, // tag and size of nested a
+                            0x0A, 0x01, 0x01, // x
                             0x15, 0x00, 0x00, 0x80, 0x3F, // y
                             0x18, 0x02, // z
                             // And back to the parent message with field v.
@@ -214,9 +235,10 @@ TEST(NestedMessage, deserialize_one)
   EXPECT_EQ(::EmbeddedProto::Error::NO_ERRORS, msg.deserialize(buffer));
 
   EXPECT_EQ(1.0F, msg.get_u());
-  EXPECT_EQ(1, msg.get_nested_a().get_x());
+  EXPECT_EQ(1, msg.get_nested_a().get_x().get_length());
+  EXPECT_EQ(1, msg.get_nested_a().x(0));
   EXPECT_EQ(1.0F, msg.get_nested_a().get_y());
-  EXPECT_EQ(1, msg.get_nested_a().get_x());
+  EXPECT_EQ(1, msg.get_nested_a().get_z());
   EXPECT_EQ(1, msg.get_v());
 }
 
@@ -224,20 +246,20 @@ TEST(NestedMessage, deserialize_nested_in_nested_max)
 {
   InSequence s;
 
-  ::message_c msg;
+  ::message_c<SIZE_MSG_A> msg;
   Mocks::ReadBufferMock buffer;
 
 
-  static constexpr uint32_t SIZE = 41;
+  static constexpr uint32_t SIZE = 42;
 
   ON_CALL(buffer, get_size()).WillByDefault(Return(SIZE));
 
   // Test if a double nested message can be deserialized with values set to maximum.
 
-  uint8_t referee[SIZE] = { 0x0A, 0x27, // tag and size of nested b
+  uint8_t referee[SIZE] = { 0x0A, 0x28, // tag and size of nested b
                             0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x7F, // u
-                            0x12, 0x16, // tag and size of nested a
-                            0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
+                            0x12, 0x17, // tag and size of nested a
+                            0x0A, 0x05, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, // x
                             0x15, 0xFF, 0xFF, 0x7F, 0x7F, // y
                             0x18, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, // z
                             // And back to the parent message with field v.
@@ -251,7 +273,8 @@ TEST(NestedMessage, deserialize_nested_in_nested_max)
   EXPECT_EQ(::EmbeddedProto::Error::NO_ERRORS, msg.deserialize(buffer));
 
   EXPECT_EQ(std::numeric_limits<double>::max(), msg.get_nested_b().get_u());
-  EXPECT_EQ(std::numeric_limits<int32_t>::max(), msg.get_nested_b().get_nested_a().get_x());
+  EXPECT_EQ(1, msg.get_nested_b().get_nested_a().get_x().get_length());
+  EXPECT_EQ(std::numeric_limits<int32_t>::max(), msg.get_nested_b().get_nested_a().x(0));
   EXPECT_EQ(std::numeric_limits<float>::max(), msg.get_nested_b().get_nested_a().get_y());
   EXPECT_EQ(std::numeric_limits<int64_t>::max(), msg.get_nested_b().get_nested_a().get_z());
   EXPECT_EQ(std::numeric_limits<int32_t>::max(), msg.get_nested_b().get_v());

test_data.py

@@ -99,17 +99,17 @@ def test_simple_types():
 def test_nested_message():
     msg = nm.message_b()
 
-    # msg.u = 1.0
-    # msg.v = 1.0
-    # msg.nested_a.x = 1
-    # msg.nested_a.y = 1.0
-    # msg.nested_a.z = 1
-
-    msg.u = 0 #pow(2, 1023)
-    msg.v = 0 #pow(2, 1023)
-    #msg.nested_a.x = 0#pow(2, 31) - 1
-    #msg.nested_a.y = 0 #1.0
-    #msg.nested_a.z = 0 #1
+    #msg.u = 1.0
+    #msg.v = 1
+    #msg.nested_a.x.append(1)
+    #msg.nested_a.y = 1.0
+    #msg.nested_a.z = 1
+
+    msg.u = 1.7976931348623157e+308         # Max double 1.7976931348623157e+308
+    msg.v = pow(2, 31) - 1                  # Max int32
+    msg.nested_a.x.append(pow(2, 31) - 1)   # Max int32
+    msg.nested_a.y = 3.40282347e+38         # Max float
+    msg.nested_a.z = 9223372036854775807    # Max sint64
 
     str = ""
     msg_str = msg.SerializeToString()
@@ -269,8 +269,8 @@ def test_included_proto():
 #test_repeated_fields()
 #test_repeated_message()
 #test_string()
-test_bytes()
-#test_nested_message()
+#test_bytes()
+test_nested_message()
 #test_oneof_fields()
 #test_included_proto()