Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Kitware
GitHub Repository: Kitware/CMake
 Path: blob/master/Utilities/cmcppdap/src/json_serializer_test.cpp
3153 views
1
// Copyright 2019 Google LLC

2
//

3
// Licensed under the Apache License, Version 2.0 (the "License");

4
// you may not use this file except in compliance with the License.

5
// You may obtain a copy of the License at

6
//

7
//     https://www.apache.org/licenses/LICENSE-2.0

8
//

9
// Unless required by applicable law or agreed to in writing, software

10
// distributed under the License is distributed on an "AS IS" BASIS,

11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

12
// See the License for the specific language governing permissions and

13
// limitations under the License.

14


15
#include "json_serializer.h"

16


17
#include "dap/typeinfo.h"

18
#include "dap/typeof.h"

19


20
#include "gmock/gmock.h"

21
#include "gtest/gtest.h"

22


23
namespace dap {

24


25
struct JSONInnerTestObject {

26
  integer i;

27
};

28


29
DAP_STRUCT_TYPEINFO(JSONInnerTestObject,

30
                    "json-inner-test-object",

31
                    DAP_FIELD(i, "i"));

32


33
struct JSONTestObject {

34
  boolean b;

35
  integer i;

36
  number n;

37
  array<integer> a;

38
  object o;

39
  string s;

40
  optional<integer> o1;

41
  optional<integer> o2;

42
  JSONInnerTestObject inner;

43
};

44


45
DAP_STRUCT_TYPEINFO(JSONTestObject,

46
                    "json-test-object",

47
                    DAP_FIELD(b, "b"),

48
                    DAP_FIELD(i, "i"),

49
                    DAP_FIELD(n, "n"),

50
                    DAP_FIELD(a, "a"),

51
                    DAP_FIELD(o, "o"),

52
                    DAP_FIELD(s, "s"),

53
                    DAP_FIELD(o1, "o1"),

54
                    DAP_FIELD(o2, "o2"),

55
                    DAP_FIELD(inner, "inner"));

56


57
struct JSONObjectNoFields {};

58


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

60


61
struct SimpleJSONTestObject {

62
  boolean b;

63
  integer i;

64
};

65
DAP_STRUCT_TYPEINFO(SimpleJSONTestObject,

66
                    "simple-json-test-object",

67
                    DAP_FIELD(b, "b"),

68
                    DAP_FIELD(i, "i"));

69


70
}  // namespace dap

71


72
class JSONSerializer : public testing::Test {

73
 protected:

74
  static dap::object GetSimpleObject() {

75
    return dap::object({{"one", dap::integer(1)},

76
                        {"two", dap::number(2)},

77
                        {"three", dap::string("three")},

78
                        {"four", dap::boolean(true)}});

79
  }

80
  void TEST_SIMPLE_OBJECT(const dap::object& obj) {

81
    NESTED_TEST_FAILED = true;

82
    auto ref_obj = GetSimpleObject();

83
    ASSERT_EQ(obj.size(), ref_obj.size());

84
    ASSERT_TRUE(obj.at("one").is<dap::integer>());

85
    ASSERT_TRUE(obj.at("two").is<dap::number>());

86
    ASSERT_TRUE(obj.at("three").is<dap::string>());

87
    ASSERT_TRUE(obj.at("four").is<dap::boolean>());

88


89
    ASSERT_EQ(ref_obj.at("one").get<dap::integer>(),

90
              obj.at("one").get<dap::integer>());

91
    ASSERT_EQ(ref_obj.at("two").get<dap::number>(),

92
              obj.at("two").get<dap::number>());

93
    ASSERT_EQ(ref_obj.at("three").get<dap::string>(),

94
              obj.at("three").get<dap::string>());

95
    ASSERT_EQ(ref_obj.at("four").get<dap::boolean>(),

96
              obj.at("four").get<dap::boolean>());

97
    NESTED_TEST_FAILED = false;

98
  }

99
  template <typename T>

100
  void TEST_SERIALIZING_DESERIALIZING(const T& encoded, T& decoded) {

101
    NESTED_TEST_FAILED = true;

102
    dap::json::Serializer s;

103
    ASSERT_TRUE(s.serialize(encoded));

104
    dap::json::Deserializer d(s.dump());

105
    ASSERT_TRUE(d.deserialize(&decoded));

106
    NESTED_TEST_FAILED = false;

107
  }

108
  bool NESTED_TEST_FAILED = false;

109
#define _ASSERT_PASS(NESTED_TEST) \

110
  NESTED_TEST;                    \

111
  ASSERT_FALSE(NESTED_TEST_FAILED);

112
};

113


114
TEST_F(JSONSerializer, SerializeDeserialize) {

115
  dap::JSONTestObject encoded;

116
  encoded.b = true;

117
  encoded.i = 32;

118
  encoded.n = 123.456;

119
  encoded.a = {2, 4, 6, 8, 0x100000000, -2, -4, -6, -8, -0x100000000};

120
  encoded.o["one"] = dap::integer(1);

121
  encoded.o["two"] = dap::number(2);

122
  encoded.s = "hello world";

123
  encoded.o2 = 42;

124
  encoded.inner.i = 70;

125


126
  dap::json::Serializer s;

127
  ASSERT_TRUE(s.serialize(encoded));

128


129
  dap::JSONTestObject decoded;

130
  dap::json::Deserializer d(s.dump());

131
  ASSERT_TRUE(d.deserialize(&decoded));

132


133
  ASSERT_EQ(encoded.b, decoded.b);

134
  ASSERT_EQ(encoded.i, decoded.i);

135
  ASSERT_EQ(encoded.n, decoded.n);

136
  ASSERT_EQ(encoded.a, decoded.a);

137
  ASSERT_EQ(encoded.o["one"].get<dap::integer>(),

138
            decoded.o["one"].get<dap::integer>());

139
  ASSERT_EQ(encoded.o["two"].get<dap::number>(),

140
            decoded.o["two"].get<dap::number>());

141
  ASSERT_EQ(encoded.s, decoded.s);

142
  ASSERT_EQ(encoded.o2, decoded.o2);

143
  ASSERT_EQ(encoded.inner.i, decoded.inner.i);

144
}

145


146
TEST_F(JSONSerializer, SerializeObjectNoFields) {

147
  dap::JSONObjectNoFields obj;

148
  dap::json::Serializer s;

149
  ASSERT_TRUE(s.serialize(obj));

150
  ASSERT_EQ(s.dump(), "{}");

151
}

152


153
TEST_F(JSONSerializer, SerializeDeserializeObject) {

154
  dap::object encoded = GetSimpleObject();

155
  dap::object decoded;

156
  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));

157
  _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded));

158
}

159


160
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObject) {

161
  dap::object encoded;

162
  dap::object decoded;

163
  // object nested inside object

164
  dap::object encoded_embed_obj = GetSimpleObject();

165
  dap::object decoded_embed_obj;

166
  encoded["embed_obj"] = encoded_embed_obj;

167
  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));

168
  ASSERT_TRUE(decoded["embed_obj"].is<dap::object>());

169
  decoded_embed_obj = decoded["embed_obj"].get<dap::object>();

170
  _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_obj));

171
}

172


173
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedStruct) {

174
  dap::object encoded;

175
  dap::object decoded;

176
  // object nested inside object

177
  dap::SimpleJSONTestObject encoded_embed_struct;

178
  encoded_embed_struct.b = true;

179
  encoded_embed_struct.i = 50;

180
  encoded["embed_struct"] = encoded_embed_struct;

181


182
  dap::object decoded_embed_obj;

183
  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));

184
  ASSERT_TRUE(decoded["embed_struct"].is<dap::object>());

185
  decoded_embed_obj = decoded["embed_struct"].get<dap::object>();

186
  ASSERT_TRUE(decoded_embed_obj.at("b").is<dap::boolean>());

187
  ASSERT_TRUE(decoded_embed_obj.at("i").is<dap::integer>());

188


189
  ASSERT_EQ(encoded_embed_struct.b, decoded_embed_obj["b"].get<dap::boolean>());

190
  ASSERT_EQ(encoded_embed_struct.i, decoded_embed_obj["i"].get<dap::integer>());

191
}

192


193
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedIntArray) {

194
  dap::object encoded;

195
  dap::object decoded;

196
  // array nested inside object

197
  dap::array<dap::integer> encoded_embed_arr = {1, 2, 3, 4};

198
  dap::array<dap::any> decoded_embed_arr;

199


200
  encoded["embed_arr"] = encoded_embed_arr;

201


202
  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));

203
  // TODO: Deserializing array should infer basic member types

204
  ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());

205
  decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();

206
  ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());

207
  for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {

208
    ASSERT_TRUE(decoded_embed_arr[i].is<dap::integer>());

209
    ASSERT_EQ(encoded_embed_arr[i], decoded_embed_arr[i].get<dap::integer>());

210
  }

211
}

212


213
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObjectArray) {

214
  dap::object encoded;

215
  dap::object decoded;

216


217
  dap::array<dap::object> encoded_embed_arr = {GetSimpleObject(),

218
                                               GetSimpleObject()};

219
  dap::array<dap::any> decoded_embed_arr;

220


221
  encoded["embed_arr"] = encoded_embed_arr;

222


223
  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));

224
  // TODO: Deserializing array should infer basic member types

225
  ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());

226
  decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();

227
  ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());

228
  for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {

229
    ASSERT_TRUE(decoded_embed_arr[i].is<dap::object>());

230
    _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_arr[i].get<dap::object>()));

231
  }

232
}

233


234
TEST_F(JSONSerializer, DeserializeSerializeEmptyObject) {

235
  auto empty_obj = "{}";

236
  dap::object decoded;

237
  dap::json::Deserializer d(empty_obj);

238
  ASSERT_TRUE(d.deserialize(&decoded));

239
  dap::json::Serializer s;

240
  ASSERT_TRUE(s.serialize(decoded));

241
  ASSERT_EQ(s.dump(), empty_obj);

242
}

243


244
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedEmptyObject) {

245
  dap::object encoded_empty_obj;

246
  dap::object encoded = {{"empty_obj", encoded_empty_obj}};

247
  dap::object decoded;

248


249
  _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));

250
  ASSERT_TRUE(decoded["empty_obj"].is<dap::object>());

251
  dap::object decoded_empty_obj = decoded["empty_obj"].get<dap::object>();

252
  ASSERT_EQ(encoded_empty_obj.size(), decoded_empty_obj.size());

253
}

254


255
TEST_F(JSONSerializer, SerializeDeserializeObjectWithNulledField) {

256
  auto thing = dap::any(dap::null());

257
  dap::object encoded;

258
  encoded["nulled_field"] = dap::null();

259
  dap::json::Serializer s;

260
  ASSERT_TRUE(s.serialize(encoded));

261
  dap::object decoded;

262
  auto dump = s.dump();

263
  dap::json::Deserializer d(dump);

264
  ASSERT_TRUE(d.deserialize(&decoded));

265
  ASSERT_TRUE(encoded["nulled_field"].is<dap::null>());

266
}

267


268