Fix any, embedded object, array, and struct serialization (#94)

* add embedded object serialization tests (failing) * Add empty object tests (failing) * test for deserializing null field object (failing) * Fix embedded object deserialization * Fix serializing empty objects on nlohmann * Fix nullptr_t handling in `any` * Add test for de/serializing struct embedded in `object` * Remove extraneous `get()` from `any` * fix compiler errors and warnings on gcc * add `any = dap::null` assignment test * Remove extraneous template
2023-02-16 15:09:45 -08:00 · 2023-02-16 15:09:45 -08:00 · 315ffff9e7
commit 315ffff9e7
parent d9041149a8
6 changed files with 273 additions and 13 deletions
--- a/include/dap/any.h
+++ b/include/dap/any.h
@ -23,6 +23,8 @@ namespace dap {

 template <typename T>
 struct TypeOf;
+class Deserializer;
+class Serializer;

 // any provides a type-safe container for values of any of dap type (boolean,
 // integer, number, array, variant, any, null, dap-structs).
@ -47,6 +49,7 @@ class any {
  inline any& operator=(any&& rhs) noexcept;
  template <typename T>
  inline any& operator=(const T& val);
+  inline any& operator=(const std::nullptr_t& val);

  // get() returns the contained value of the type T.
  // If the any does not contain a value of type T, then get() will assert.
@ -58,6 +61,9 @@ class any {
  inline bool is() const;

 private:
+  friend class Deserializer;
+  friend class Serializer;
+
  static inline void* alignUp(void* val, size_t alignment);
  inline void alloc(size_t size, size_t align);
  inline void free();
@ -142,8 +148,15 @@ any& any::operator=(const T& val) {
  return *this;
 }

+any& any::operator=(const std::nullptr_t&) {
+  reset();
+  return *this;
+}
+
 template <typename T>
 T& any::get() const {
+  static_assert(!std::is_same<T, std::nullptr_t>(),
+                "Cannot get nullptr from 'any'.");
  assert(is<T>());
  return *reinterpret_cast<T*>(value);
 }
--- a/include/dap/serialization.h
+++ b/include/dap/serialization.h
@ -177,8 +177,18 @@ class Serializer {

  // deserialize() encodes the given string.
  inline bool serialize(const char* v);
+ protected:
+  static inline const TypeInfo* get_any_type(const any&);
+  static inline const void* get_any_val(const any&);
 };

+inline const TypeInfo* Serializer::get_any_type(const any& a){
+  return a.type;
+}
+const void* Serializer::get_any_val(const any& a) {
+  return a.value;
+}
+
 template <typename T, typename>
 bool Serializer::serialize(const T& object) {
  return TypeOf<T>::type()->serialize(this, &object);
--- a/src/any_test.cpp
+++ b/src/any_test.cpp
@ -42,6 +42,10 @@ namespace {
 template <typename T>
 struct TestValue {};

+template <>
+struct TestValue<dap::null> {
+  static const dap::null value;
+};
 template <>
 struct TestValue<dap::integer> {
  static const dap::integer value;
@ -67,6 +71,7 @@ struct TestValue<dap::AnyTestObject> {
  static const dap::AnyTestObject value;
 };

+const dap::null TestValue<dap::null>::value = nullptr;
 const dap::integer TestValue<dap::integer>::value = 20;
 const dap::boolean TestValue<dap::boolean>::value = true;
 const dap::number TestValue<dap::number>::value = 123.45;
@ -152,7 +157,24 @@ TEST(Any, TestObject) {
 template <typename T>
 class AnyT : public ::testing::Test {
 protected:
-  void check(const dap::any& any, const T& expect) {
+  template <typename T0,
+            typename = std::enable_if<std::is_same<T, T0>::value &&
+                                      !std::is_same<T0, dap::null>::value>>
+  void check_val(const dap::any& any, const T0& expect) {
+    ASSERT_EQ(any.is<T>(), any.is<T0>());
+    ASSERT_EQ(any.get<T>(), expect);
+  }
+
+  // Special case for Null assignment, as we can assign nullptr_t to any but
+  // can't `get()` it
+  template <typename = dap::null>
+  void check_val(const dap::any& any, const dap::null& expect) {
+    ASSERT_EQ(nullptr, expect);
+    ASSERT_TRUE(any.is<dap::null>());
+  }
+
+  void check_type(const dap::any& any) {
+    ASSERT_EQ(any.is<dap::null>(), (std::is_same<T, dap::null>::value));
    ASSERT_EQ(any.is<dap::integer>(), (std::is_same<T, dap::integer>::value));
    ASSERT_EQ(any.is<dap::boolean>(), (std::is_same<T, dap::boolean>::value));
    ASSERT_EQ(any.is<dap::number>(), (std::is_same<T, dap::number>::value));
@ -161,8 +183,6 @@ class AnyT : public ::testing::Test {
              (std::is_same<T, dap::array<dap::string>>::value));
    ASSERT_EQ(any.is<dap::AnyTestObject>(),
              (std::is_same<T, dap::AnyTestObject>::value));
-
-    ASSERT_EQ(any.get<T>(), expect);
  }
 };
 TYPED_TEST_SUITE_P(AnyT);
@ -170,27 +190,31 @@ TYPED_TEST_SUITE_P(AnyT);
 TYPED_TEST_P(AnyT, CopyConstruct) {
  auto val = TestValue<TypeParam>::value;
  dap::any any(val);
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }

 TYPED_TEST_P(AnyT, MoveConstruct) {
  auto val = TestValue<TypeParam>::value;
  dap::any any(std::move(val));
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }

 TYPED_TEST_P(AnyT, Assign) {
  auto val = TestValue<TypeParam>::value;
  dap::any any;
  any = val;
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }

 TYPED_TEST_P(AnyT, MoveAssign) {
  auto val = TestValue<TypeParam>::value;
  dap::any any;
  any = std::move(val);
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }

 TYPED_TEST_P(AnyT, RepeatedAssign) {
@ -199,7 +223,8 @@ TYPED_TEST_P(AnyT, RepeatedAssign) {
  dap::any any;
  any = str;
  any = val;
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }

 TYPED_TEST_P(AnyT, RepeatedMoveAssign) {
@ -208,7 +233,8 @@ TYPED_TEST_P(AnyT, RepeatedMoveAssign) {
  dap::any any;
  any = std::move(str);
  any = std::move(val);
-  this->check(any, val);
+  this->check_type(any);
+  this->check_val(any, val);
 }

 REGISTER_TYPED_TEST_SUITE_P(AnyT,
@ -219,7 +245,8 @@ REGISTER_TYPED_TEST_SUITE_P(AnyT,
                            RepeatedAssign,
                            RepeatedMoveAssign);

-using AnyTypes = ::testing::Types<dap::integer,
+using AnyTypes = ::testing::Types<dap::null,
+                                  dap::integer,
                                  dap::boolean,
                                  dap::number,
                                  dap::string,
--- a/src/json_serializer_test.cpp
+++ b/src/json_serializer_test.cpp
@ -58,9 +58,60 @@ struct JSONObjectNoFields {};

 DAP_STRUCT_TYPEINFO(JSONObjectNoFields, "json-object-no-fields");

+struct SimpleJSONTestObject {
+  boolean b;
+  integer i;
+};
+DAP_STRUCT_TYPEINFO(SimpleJSONTestObject,
+                    "simple-json-test-object",
+                    DAP_FIELD(b, "b"),
+                    DAP_FIELD(i, "i"));
+
 }  // namespace dap

-TEST(JSONSerializer, SerializeDeserialize) {
+class JSONSerializer : public testing::Test {
+ protected:
+  static dap::object GetSimpleObject() {
+    return dap::object({{"one", dap::integer(1)},
+                        {"two", dap::number(2)},
+                        {"three", dap::string("three")},
+                        {"four", dap::boolean(true)}});
+  }
+  void TEST_SIMPLE_OBJECT(const dap::object& obj) {
+    NESTED_TEST_FAILED = true;
+    auto ref_obj = GetSimpleObject();
+    ASSERT_EQ(obj.size(), ref_obj.size());
+    ASSERT_TRUE(obj.at("one").is<dap::integer>());
+    ASSERT_TRUE(obj.at("two").is<dap::number>());
+    ASSERT_TRUE(obj.at("three").is<dap::string>());
+    ASSERT_TRUE(obj.at("four").is<dap::boolean>());
+
+    ASSERT_EQ(ref_obj.at("one").get<dap::integer>(),
+              obj.at("one").get<dap::integer>());
+    ASSERT_EQ(ref_obj.at("two").get<dap::number>(),
+              obj.at("two").get<dap::number>());
+    ASSERT_EQ(ref_obj.at("three").get<dap::string>(),
+              obj.at("three").get<dap::string>());
+    ASSERT_EQ(ref_obj.at("four").get<dap::boolean>(),
+              obj.at("four").get<dap::boolean>());
+    NESTED_TEST_FAILED = false;
+  }
+  template <typename T>
+  void TEST_SERIALIZING_DESERIALIZING(const T& encoded, T& decoded) {
+    NESTED_TEST_FAILED = true;
+    dap::json::Serializer s;
+    ASSERT_TRUE(s.serialize(encoded));
+    dap::json::Deserializer d(s.dump());
+    ASSERT_TRUE(d.deserialize(&decoded));
+    NESTED_TEST_FAILED = false;
+  }
+  bool NESTED_TEST_FAILED = false;
+#define _ASSERT_PASS(NESTED_TEST) \
+  NESTED_TEST;                    \
+  ASSERT_FALSE(NESTED_TEST_FAILED);
+};
+
+TEST_F(JSONSerializer, SerializeDeserialize) {
  dap::JSONTestObject encoded;
  encoded.b = true;
  encoded.i = 32;
@ -92,9 +143,124 @@ TEST(JSONSerializer, SerializeDeserialize) {
  ASSERT_EQ(encoded.inner.i, decoded.inner.i);
 }

-TEST(JSONSerializer, SerializeObjectNoFields) {
+TEST_F(JSONSerializer, SerializeObjectNoFields) {
  dap::JSONObjectNoFields obj;
  dap::json::Serializer s;
  ASSERT_TRUE(s.serialize(obj));
  ASSERT_EQ(s.dump(), "{}");
 }
+
+TEST_F(JSONSerializer, SerializeDeserializeObject) {
+  dap::object encoded = GetSimpleObject();
+  dap::object decoded;
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded));
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObject) {
+  dap::object encoded;
+  dap::object decoded;
+  // object nested inside object
+  dap::object encoded_embed_obj = GetSimpleObject();
+  dap::object decoded_embed_obj;
+  encoded["embed_obj"] = encoded_embed_obj;
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  ASSERT_TRUE(decoded["embed_obj"].is<dap::object>());
+  decoded_embed_obj = decoded["embed_obj"].get<dap::object>();
+  _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_obj));
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedStruct) {
+  dap::object encoded;
+  dap::object decoded;
+  // object nested inside object
+  dap::SimpleJSONTestObject encoded_embed_struct;
+  encoded_embed_struct.b = true;
+  encoded_embed_struct.i = 50;
+  encoded["embed_struct"] = encoded_embed_struct;
+
+  dap::object decoded_embed_obj;
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  ASSERT_TRUE(decoded["embed_struct"].is<dap::object>());
+  decoded_embed_obj = decoded["embed_struct"].get<dap::object>();
+  ASSERT_TRUE(decoded_embed_obj.at("b").is<dap::boolean>());
+  ASSERT_TRUE(decoded_embed_obj.at("i").is<dap::integer>());
+
+  ASSERT_EQ(encoded_embed_struct.b, decoded_embed_obj["b"].get<dap::boolean>());
+  ASSERT_EQ(encoded_embed_struct.i, decoded_embed_obj["i"].get<dap::integer>());
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedIntArray) {
+  dap::object encoded;
+  dap::object decoded;
+  // array nested inside object
+  dap::array<dap::integer> encoded_embed_arr = {1, 2, 3, 4};
+  dap::array<dap::any> decoded_embed_arr;
+
+  encoded["embed_arr"] = encoded_embed_arr;
+
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  // TODO: Deserializing array should infer basic member types
+  ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
+  decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
+  ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
+  for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
+    ASSERT_TRUE(decoded_embed_arr[i].is<dap::integer>());
+    ASSERT_EQ(encoded_embed_arr[i], decoded_embed_arr[i].get<dap::integer>());
+  }
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObjectArray) {
+  dap::object encoded;
+  dap::object decoded;
+
+  dap::array<dap::object> encoded_embed_arr = {GetSimpleObject(),
+                                               GetSimpleObject()};
+  dap::array<dap::any> decoded_embed_arr;
+
+  encoded["embed_arr"] = encoded_embed_arr;
+
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  // TODO: Deserializing array should infer basic member types
+  ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
+  decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
+  ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
+  for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
+    ASSERT_TRUE(decoded_embed_arr[i].is<dap::object>());
+    _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_arr[i].get<dap::object>()));
+  }
+}
+
+TEST_F(JSONSerializer, DeserializeSerializeEmptyObject) {
+  auto empty_obj = "{}";
+  dap::object decoded;
+  dap::json::Deserializer d(empty_obj);
+  ASSERT_TRUE(d.deserialize(&decoded));
+  dap::json::Serializer s;
+  ASSERT_TRUE(s.serialize(decoded));
+  ASSERT_EQ(s.dump(), empty_obj);
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeEmbeddedEmptyObject) {
+  dap::object encoded_empty_obj;
+  dap::object encoded = {{"empty_obj", encoded_empty_obj}};
+  dap::object decoded;
+
+  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
+  ASSERT_TRUE(decoded["empty_obj"].is<dap::object>());
+  dap::object decoded_empty_obj = decoded["empty_obj"].get<dap::object>();
+  ASSERT_EQ(encoded_empty_obj.size(), decoded_empty_obj.size());
+}
+
+TEST_F(JSONSerializer, SerializeDeserializeObjectWithNulledField) {
+  auto thing = dap::any(dap::null());
+  dap::object encoded;
+  encoded["nulled_field"] = dap::null();
+  dap::json::Serializer s;
+  ASSERT_TRUE(s.serialize(encoded));
+  dap::object decoded;
+  auto dump = s.dump();
+  dap::json::Deserializer d(dump);
+  ASSERT_TRUE(d.deserialize(&decoded));
+  ASSERT_TRUE(encoded["nulled_field"].is<dap::null>());
+}
--- a/src/nlohmann_json_serializer.cpp
+++ b/src/nlohmann_json_serializer.cpp
@ -91,6 +91,18 @@ bool NlohmannDeserializer::deserialize(dap::any* v) const {
    *v = dap::integer(json->get<int64_t>());
  } else if (json->is_string()) {
    *v = json->get<std::string>();
+  } else if (json->is_object()) {
+    dap::object obj;
+    if (!deserialize(&obj)) {
+      return false;
+    }
+    *v = obj;
+  } else if (json->is_array()) {
+    dap::array<any> arr;
+    if (!deserialize(&arr)) {
+      return false;
+    }
+    *v = arr;
  } else if (json->is_null()) {
    *v = null();
  } else {
@ -169,6 +181,9 @@ bool NlohmannSerializer::serialize(const dap::string& v) {
 }

 bool NlohmannSerializer::serialize(const dap::object& v) {
+  if (!json->is_object()) {
+    *json = nlohmann::json::object();
+  }
  for (auto& it : v) {
    NlohmannSerializer s(&(*json)[it.first]);
    if (!s.serialize(it.second)) {
@ -187,11 +202,19 @@ bool NlohmannSerializer::serialize(const dap::any& v) {
    *json = (double)v.get<dap::number>();
  } else if (v.is<dap::string>()) {
    *json = v.get<dap::string>();
+  } else if (v.is<dap::object>()) {
+    // reachable if dap::object nested is inside other dap::object
+    return serialize(v.get<dap::object>());
  } else if (v.is<dap::null>()) {
  } else {
+    // reachable if array or custom serialized type is nested inside other
+    auto type = get_any_type(v);
+    auto value = get_any_val(v);
+    if (type && value) {
+      return type->serialize(this, value);
+    }
    return false;
  }
-
  return true;
 }

--- a/src/rapid_json_serializer.cpp
+++ b/src/rapid_json_serializer.cpp
@ -98,6 +98,18 @@ bool RapidDeserializer::deserialize(dap::any* v) const {
    *v = dap::string(json()->GetString());
  } else if (json()->IsNull()) {
    *v = null();
+  } else if (json()->IsObject()) {
+    dap::object obj;
+    if (!deserialize(&obj)) {
+      return false;
+    }
+    *v = obj;
+  } else if (json()->IsArray()){
+    dap::array<any> arr;
+    if (!deserialize(&arr)){
+      return false;
+    }
+    *v = arr;
  } else {
    return false;
  }
@ -203,8 +215,17 @@ bool RapidSerializer::serialize(const dap::any& v) {
  } else if (v.is<dap::string>()) {
    auto s = v.get<dap::string>();
    json()->SetString(s.data(), static_cast<uint32_t>(s.length()), allocator);
+  } else if (v.is<dap::object>()) {
+    // reachable if dap::object nested is inside other dap::object
+    return serialize(v.get<dap::object>());
  } else if (v.is<dap::null>()) {
  } else {
+    // reachable if array or custom serialized type is nested inside other dap::object
+    auto type = get_any_type(v);
+    auto value = get_any_val(v);
+    if (type && value) {
+      return type->serialize(this, value);
+    }
    return false;
  }