1 /*
2 * Copyright 2019 Google LLC
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * https://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <cstdint>
18 #include <iomanip>
19 #include <sstream>
20
21 #include <gmock/gmock.h>
22 #include <gtest/gtest.h>
23
24 #include "cppbor.h"
25 #include "cppbor_parse.h"
26
27 using namespace cppbor;
28 using namespace std;
29
30 using ::testing::_;
31 using ::testing::ByRef;
32 using ::testing::InSequence;
33 using ::testing::IsNull;
34 using ::testing::NotNull;
35 using ::testing::Return;
36 using ::testing::Unused;
37
hexDump(const string & str)38 string hexDump(const string& str) {
39 stringstream s;
40 for (auto c : str) {
41 s << setfill('0') << setw(2) << hex << (static_cast<unsigned>(c) & 0xff);
42 }
43 return s.str();
44 }
45
TEST(SimpleValueTest,UnsignedValueSizes)46 TEST(SimpleValueTest, UnsignedValueSizes) {
47 // Check that unsigned integers encode to correct lengths, and that encodedSize() is correct.
48 vector<pair<uint64_t /* value */, size_t /* expected encoded size */>> testCases{
49 {0, 1},
50 {1, 1},
51 {23, 1},
52 {24, 2},
53 {255, 2},
54 {256, 3},
55 {65535, 3},
56 {65536, 5},
57 {4294967295, 5},
58 {4294967296, 9},
59 {std::numeric_limits<uint64_t>::max(), 9},
60 };
61 for (auto& testCase : testCases) {
62 Uint val(testCase.first);
63 EXPECT_EQ(testCase.second, val.encodedSize()) << "Wrong size for value " << testCase.first;
64 EXPECT_EQ(val.encodedSize(), val.toString().size())
65 << "encodedSize and encoding disagree for value " << testCase.first;
66 }
67 }
68
TEST(SimpleValueTest,UnsignedValueEncodings)69 TEST(SimpleValueTest, UnsignedValueEncodings) {
70 EXPECT_EQ("\x00"s, Uint(0u).toString());
71 EXPECT_EQ("\x01"s, Uint(1u).toString());
72 EXPECT_EQ("\x0a"s, Uint(10u).toString());
73 EXPECT_EQ("\x17"s, Uint(23u).toString());
74 EXPECT_EQ("\x18\x18"s, Uint(24u).toString());
75 EXPECT_EQ("\x18\x19"s, Uint(25u).toString());
76 EXPECT_EQ("\x18\x64"s, Uint(100u).toString());
77 EXPECT_EQ("\x19\x03\xe8"s, Uint(1000u).toString());
78 EXPECT_EQ("\x1a\x00\x0f\x42\x40"s, Uint(1000000u).toString());
79 EXPECT_EQ("\x1b\x00\x00\x00\xe8\xd4\xa5\x10\x00"s, Uint(1000000000000u).toString());
80 EXPECT_EQ("\x1B\x7f\xff\xff\xff\xff\xff\xff\xff"s,
81 Uint(std::numeric_limits<int64_t>::max()).toString());
82 }
83
TEST(SimpleValueTest,NegativeValueEncodings)84 TEST(SimpleValueTest, NegativeValueEncodings) {
85 EXPECT_EQ("\x20"s, Nint(-1).toString());
86 EXPECT_EQ("\x28"s, Nint(-9).toString());
87 EXPECT_EQ("\x29"s, Nint(-10).toString());
88 EXPECT_EQ("\x36"s, Nint(-23).toString());
89 EXPECT_EQ("\x37"s, Nint(-24).toString());
90 EXPECT_EQ("\x38\x18"s, Nint(-25).toString());
91 EXPECT_EQ("\x38\x62"s, Nint(-99).toString());
92 EXPECT_EQ("\x38\x63"s, Nint(-100).toString());
93 EXPECT_EQ("\x39\x03\xe6"s, Nint(-999).toString());
94 EXPECT_EQ("\x39\x03\xe7"s, Nint(-1000).toString());
95 EXPECT_EQ("\x3a\x00\x0f\x42\x3F"s, Nint(-1000000).toString());
96 EXPECT_EQ("\x3b\x00\x00\x00\xe8\xd4\xa5\x0f\xff"s, Nint(-1000000000000).toString());
97 EXPECT_EQ("\x3B\x7f\xff\xff\xff\xff\xff\xff\xff"s,
98 Nint(std::numeric_limits<int64_t>::min()).toString());
99 }
100
TEST(SimpleValueDeathTest,NegativeValueEncodings)101 TEST(SimpleValueDeathTest, NegativeValueEncodings) {
102 EXPECT_DEATH(Nint(0), "");
103 EXPECT_DEATH(Nint(1), "");
104 }
105
TEST(SimpleValueTest,BooleanEncodings)106 TEST(SimpleValueTest, BooleanEncodings) {
107 EXPECT_EQ("\xf4"s, Bool(false).toString());
108 EXPECT_EQ("\xf5"s, Bool(true).toString());
109 }
110
TEST(SimpleValueTest,NullEncodings)111 TEST(SimpleValueTest, NullEncodings) {
112 EXPECT_EQ("\xf6"s, Null().toString());
113 }
114
TEST(SimpleValueTest,ByteStringEncodings)115 TEST(SimpleValueTest, ByteStringEncodings) {
116 EXPECT_EQ("\x40", Bstr("").toString());
117 EXPECT_EQ("\x41\x61", Bstr("a").toString());
118 EXPECT_EQ("\x41\x41", Bstr("A").toString());
119 EXPECT_EQ("\x44\x49\x45\x54\x46", Bstr("IETF").toString());
120 EXPECT_EQ("\x42\x22\x5c", Bstr("\"\\").toString());
121 EXPECT_EQ("\x42\xc3\xbc", Bstr("\xc3\xbc").toString());
122 EXPECT_EQ("\x43\xe6\xb0\xb4", Bstr("\xe6\xb0\xb4").toString());
123 EXPECT_EQ("\x44\xf0\x90\x85\x91", Bstr("\xf0\x90\x85\x91").toString());
124 EXPECT_EQ("\x44\x01\x02\x03\x04", Bstr("\x01\x02\x03\x04").toString());
125 EXPECT_EQ("\x44\x40\x40\x40\x40", Bstr("@@@@").toString());
126 }
127
TEST(SimpleValueTest,TextStringEncodings)128 TEST(SimpleValueTest, TextStringEncodings) {
129 EXPECT_EQ("\x60"s, Tstr("").toString());
130 EXPECT_EQ("\x61\x61"s, Tstr("a").toString());
131 EXPECT_EQ("\x61\x41"s, Tstr("A").toString());
132 EXPECT_EQ("\x64\x49\x45\x54\x46"s, Tstr("IETF").toString());
133 EXPECT_EQ("\x62\x22\x5c"s, Tstr("\"\\").toString());
134 EXPECT_EQ("\x62\xc3\xbc"s, Tstr("\xc3\xbc").toString());
135 EXPECT_EQ("\x63\xe6\xb0\xb4"s, Tstr("\xe6\xb0\xb4").toString());
136 EXPECT_EQ("\x64\xf0\x90\x85\x91"s, Tstr("\xf0\x90\x85\x91").toString());
137 EXPECT_EQ("\x64\x01\x02\x03\x04"s, Tstr("\x01\x02\x03\x04").toString());
138 }
139
TEST(SimpleValueTest,SemanticTagEncoding)140 TEST(SimpleValueTest, SemanticTagEncoding) {
141 EXPECT_EQ("\xDB\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x63\x41\x45\x53"s,
142 SemanticTag(std::numeric_limits<uint64_t>::max(), "AES").toString());
143 }
144
TEST(SimpleValueTest,NestedSemanticTagEncoding)145 TEST(SimpleValueTest, NestedSemanticTagEncoding) {
146 auto tripleTagged =
147 SemanticTag(254,
148 SemanticTag(1, //
149 SemanticTag(std::numeric_limits<uint64_t>::max(), //
150 "AES")));
151 EXPECT_EQ("\xD8\xFE\xC1\xDB\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x63\x41\x45\x53"s,
152 tripleTagged.toString());
153 }
154
TEST(SimpleValueTest,ViewByteStringEncodings)155 TEST(SimpleValueTest, ViewByteStringEncodings) {
156 EXPECT_EQ("\x40", ViewBstr("").toString());
157 EXPECT_EQ("\x41\x61", ViewBstr("a").toString());
158 EXPECT_EQ("\x41\x41", ViewBstr("A").toString());
159 EXPECT_EQ("\x44\x49\x45\x54\x46", ViewBstr("IETF").toString());
160 EXPECT_EQ("\x42\x22\x5c", ViewBstr("\"\\").toString());
161 EXPECT_EQ("\x42\xc3\xbc", ViewBstr("\xc3\xbc").toString());
162 EXPECT_EQ("\x43\xe6\xb0\xb4", ViewBstr("\xe6\xb0\xb4").toString());
163 EXPECT_EQ("\x44\xf0\x90\x85\x91", ViewBstr("\xf0\x90\x85\x91").toString());
164 EXPECT_EQ("\x44\x01\x02\x03\x04", ViewBstr("\x01\x02\x03\x04").toString());
165 EXPECT_EQ("\x44\x40\x40\x40\x40", ViewBstr("@@@@").toString());
166 }
167
TEST(SimpleValueTest,ViewTextStringEncodings)168 TEST(SimpleValueTest, ViewTextStringEncodings) {
169 EXPECT_EQ("\x60"s, ViewTstr("").toString());
170 EXPECT_EQ("\x61\x61"s, ViewTstr("a").toString());
171 EXPECT_EQ("\x61\x41"s, ViewTstr("A").toString());
172 EXPECT_EQ("\x64\x49\x45\x54\x46"s, ViewTstr("IETF").toString());
173 EXPECT_EQ("\x62\x22\x5c"s, ViewTstr("\"\\").toString());
174 EXPECT_EQ("\x62\xc3\xbc"s, ViewTstr("\xc3\xbc").toString());
175 EXPECT_EQ("\x63\xe6\xb0\xb4"s, ViewTstr("\xe6\xb0\xb4").toString());
176 EXPECT_EQ("\x64\xf0\x90\x85\x91"s, ViewTstr("\xf0\x90\x85\x91").toString());
177 EXPECT_EQ("\x64\x01\x02\x03\x04"s, ViewTstr("\x01\x02\x03\x04").toString());
178 }
179
TEST(IsIteratorPairOverTest,All)180 TEST(IsIteratorPairOverTest, All) {
181 EXPECT_TRUE((
182 details::is_iterator_pair_over<pair<string::iterator, string::iterator>, char>::value));
183 EXPECT_TRUE((details::is_iterator_pair_over<pair<string::const_iterator, string::iterator>,
184 char>::value));
185 EXPECT_TRUE((details::is_iterator_pair_over<pair<string::iterator, string::const_iterator>,
186 char>::value));
187 EXPECT_TRUE((details::is_iterator_pair_over<pair<char*, char*>, char>::value));
188 EXPECT_TRUE((details::is_iterator_pair_over<pair<const char*, char*>, char>::value));
189 EXPECT_TRUE((details::is_iterator_pair_over<pair<char*, const char*>, char>::value));
190 EXPECT_FALSE((details::is_iterator_pair_over<pair<string::iterator, string::iterator>,
191 uint8_t>::value));
192 EXPECT_FALSE((details::is_iterator_pair_over<pair<char*, char*>, uint8_t>::value));
193 EXPECT_TRUE((details::is_iterator_pair_over<
194 pair<vector<uint8_t>::iterator, vector<uint8_t>::iterator>, uint8_t>::value));
195 EXPECT_TRUE((details::is_iterator_pair_over<
196 pair<vector<uint8_t>::const_iterator, vector<uint8_t>::iterator>,
197 uint8_t>::value));
198 EXPECT_TRUE((details::is_iterator_pair_over<
199 pair<vector<uint8_t>::iterator, vector<uint8_t>::const_iterator>,
200 uint8_t>::value));
201 EXPECT_TRUE((details::is_iterator_pair_over<pair<uint8_t*, uint8_t*>, uint8_t>::value));
202 EXPECT_TRUE((details::is_iterator_pair_over<pair<const uint8_t*, uint8_t*>, uint8_t>::value));
203 EXPECT_TRUE((details::is_iterator_pair_over<pair<uint8_t*, const uint8_t*>, uint8_t>::value));
204 EXPECT_FALSE((details::is_iterator_pair_over<
205 pair<vector<uint8_t>::iterator, vector<uint8_t>::iterator>, char>::value));
206 EXPECT_FALSE((details::is_iterator_pair_over<pair<uint8_t*, const uint8_t*>, char>::value));
207 }
208
TEST(IsUniquePtrSubclassOf,All)209 TEST(IsUniquePtrSubclassOf, All) {
210 EXPECT_TRUE((details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<Bool>>::value));
211 EXPECT_TRUE((details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<Map>>::value));
212 EXPECT_TRUE((details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<Array>>::value));
213 EXPECT_TRUE(
214 (details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<SemanticTag>>::value));
215 EXPECT_FALSE(
216 (details::is_unique_ptr_of_subclass_of_v<std::string, std::unique_ptr<Bool>>::value));
217 EXPECT_FALSE((
218 details::is_unique_ptr_of_subclass_of_v<uint8_t, std::unique_ptr<std::string>>::value));
219 }
220
TEST(MakeEntryTest,Boolean)221 TEST(MakeEntryTest, Boolean) {
222 EXPECT_EQ("\xf4"s, details::makeItem(false)->toString());
223 }
224
TEST(MakeEntryTest,Null)225 TEST(MakeEntryTest, Null) {
226 EXPECT_EQ("\xf6"s, details::makeItem(nullptr)->toString());
227 }
228
TEST(MakeEntryTest,Integers)229 TEST(MakeEntryTest, Integers) {
230 EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint8_t>(0))->toString());
231 EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint16_t>(0))->toString());
232 EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint32_t>(0))->toString());
233 EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint64_t>(0))->toString());
234 EXPECT_EQ("\x00"s, details::makeItem(static_cast<int8_t>(0))->toString());
235 EXPECT_EQ("\x00"s, details::makeItem(static_cast<int16_t>(0))->toString());
236 EXPECT_EQ("\x00"s, details::makeItem(static_cast<int32_t>(0))->toString());
237 EXPECT_EQ("\x00"s, details::makeItem(static_cast<int64_t>(0))->toString());
238 EXPECT_EQ("\x20"s, details::makeItem(static_cast<int8_t>(-1))->toString());
239 EXPECT_EQ("\x20"s, details::makeItem(static_cast<int16_t>(-1))->toString());
240 EXPECT_EQ("\x20"s, details::makeItem(static_cast<int32_t>(-1))->toString());
241 EXPECT_EQ("\x20"s, details::makeItem(static_cast<int64_t>(-1))->toString());
242
243 EXPECT_EQ("\x1b\xff\xff\xff\xff\xff\xff\xff\xff"s,
244 details::makeItem(static_cast<uint64_t>(std::numeric_limits<uint64_t>::max()))
245 ->toString());
246 }
247
TEST(MakeEntryTest,StdStrings)248 TEST(MakeEntryTest, StdStrings) {
249 string s1("hello");
250 const string s2("hello");
251 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s1)->toString()); // copy of string
252 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s,
253 details::makeItem(s2)->toString()); // copy of const string
254 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s,
255 details::makeItem(std::move(s1))->toString()); // move string
256 }
257
TEST(MakeEntryTest,StdStringViews)258 TEST(MakeEntryTest, StdStringViews) {
259 string_view s1("hello");
260 const string_view s2("hello");
261 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s1)->toString());
262 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s2)->toString());
263 }
264
TEST(MakeEntryTest,CStrings)265 TEST(MakeEntryTest, CStrings) {
266 char s1[] = "hello";
267 const char s2[] = "hello";
268 const char* s3 = "hello";
269 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s1)->toString());
270 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s2)->toString());
271 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s3)->toString());
272 }
273
TEST(MakeEntryTest,StringIteratorPairs)274 TEST(MakeEntryTest, StringIteratorPairs) {
275 // Use iterators from string to prove that "real" iterators work
276 string s1 = "hello"s;
277 pair<string::iterator, string::iterator> p1 = make_pair(s1.begin(), s1.end());
278
279 const pair<string::iterator, string::iterator> p2 = p1;
280 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p1)->toString());
281 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p2)->toString());
282
283 // Use char*s as iterators
284 const char* s2 = "hello";
285 pair p3 = make_pair(s2, s2 + 5);
286 const pair p4 = p3;
287 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p3)->toString());
288 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p4)->toString());
289 }
290
TEST(MakeEntryTest,ByteStrings)291 TEST(MakeEntryTest, ByteStrings) {
292 vector<uint8_t> v1 = {0x00, 0x01, 0x02};
293 const vector<uint8_t> v2 = {0x00, 0x01, 0x02};
294 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(v1)->toString()); // copy of vector
295 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(v2)->toString()); // copy of const vector
296 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(std::move(v1))->toString()); // move vector
297 EXPECT_EQ(0U, v1.size()); // Prove vector was moved, not copied.
298 }
299
TEST(MakeEntryTest,ByteStringIteratorPairs)300 TEST(MakeEntryTest, ByteStringIteratorPairs) {
301 using vec = vector<uint8_t>;
302 using iter = vec::iterator;
303 vec v1 = {0x00, 0x01, 0x02};
304 pair<iter, iter> p1 = make_pair(v1.begin(), v1.end());
305 const pair<iter, iter> p2 = make_pair(v1.begin(), v1.end());
306 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p1)->toString());
307 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p2)->toString());
308
309 // Use uint8_t*s as iterators
310 uint8_t v2[] = {0x00, 0x01, 0x02};
311 uint8_t* v3 = v2;
312 pair<uint8_t*, uint8_t*> p3 = make_pair(v2, v2 + 3);
313 const pair<uint8_t*, uint8_t*> p4 = make_pair(v2, v2 + 3);
314 pair<uint8_t*, uint8_t*> p5 = make_pair(v3, v3 + 3);
315 const pair<uint8_t*, uint8_t*> p6 = make_pair(v3, v3 + 3);
316 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p3)->toString());
317 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p4)->toString());
318 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p5)->toString());
319 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p6)->toString());
320 }
321
TEST(MakeEntryTest,ByteStringBuffers)322 TEST(MakeEntryTest, ByteStringBuffers) {
323 uint8_t v1[] = {0x00, 0x01, 0x02};
324 EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(make_pair(v1, 3))->toString());
325 }
326
TEST(MakeEntryTest,ItemPointer)327 TEST(MakeEntryTest, ItemPointer) {
328 Uint* p1 = new Uint(0);
329 EXPECT_EQ("\x00"s, details::makeItem(p1)->toString());
330 EXPECT_EQ("\x60"s, details::makeItem(new Tstr(string()))->toString());
331 }
332
TEST(MakeEntryTest,ItemReference)333 TEST(MakeEntryTest, ItemReference) {
334 Tstr str("hello"s);
335 Tstr& strRef = str;
336 const Tstr& strConstRef = str;
337 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(str)->toString());
338 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(strRef)->toString());
339 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(strConstRef)->toString());
340 EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(std::move(str))->toString());
341 EXPECT_EQ("\x60"s, details::makeItem(str)->toString()); // Prove that it moved
342
343 EXPECT_EQ("\x00"s, details::makeItem(Uint(0))->toString());
344
345 EXPECT_EQ("\x43\x00\x01\x02"s,
346 details::makeItem(Bstr(vector<uint8_t>{0x00, 0x01, 0x02}))->toString());
347
348 EXPECT_EQ("\x80"s, details::makeItem(Array())->toString());
349 EXPECT_EQ("\xa0"s, details::makeItem(Map())->toString());
350 }
351
TEST(CompoundValueTest,ArrayOfInts)352 TEST(CompoundValueTest, ArrayOfInts) {
353 EXPECT_EQ("\x80"s, Array().toString());
354 Array(Uint(0)).toString();
355
356 EXPECT_EQ("\x81\x00"s, Array(Uint(0U)).toString());
357 EXPECT_EQ("\x82\x00\x01"s, Array(Uint(0), Uint(1)).toString());
358 EXPECT_EQ("\x83\x00\x01\x38\x62"s, Array(Uint(0), Uint(1), Nint(-99)).toString());
359
360 EXPECT_EQ("\x81\x00"s, Array(0).toString());
361 EXPECT_EQ("\x82\x00\x01"s, Array(0, 1).toString());
362 EXPECT_EQ("\x83\x00\x01\x38\x62"s, Array(0, 1, -99).toString());
363 }
364
TEST(CompoundValueTest,MapOfInts)365 TEST(CompoundValueTest, MapOfInts) {
366 EXPECT_EQ("\xA0"s, Map().toString());
367 EXPECT_EQ("\xA1\x00\x01"s, Map(Uint(0), Uint(1)).toString());
368 // Maps with an odd number of arguments will fail to compile. Uncomment the next lines to test.
369 // EXPECT_EQ("\xA1\x00"s, Map(Int(0)).toString());
370 // EXPECT_EQ("\xA1\x00\x01\x02"s, Map(Int(0), Int(1), Int(2)).toString());
371 }
372
TEST(CompoundValueTest,MixedArray)373 TEST(CompoundValueTest, MixedArray) {
374 vector<uint8_t> vec = {3, 2, 1};
375 EXPECT_EQ("\x84\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s,
376 Array(Uint(1), Nint(-1), Bstr(vec), Tstr("hello")).toString());
377
378 EXPECT_EQ("\x84\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s,
379 Array(1, -1, vec, "hello").toString());
380 }
381
TEST(CompoundValueTest,MixedMap)382 TEST(CompoundValueTest, MixedMap) {
383 vector<uint8_t> vec = {3, 2, 1};
384 EXPECT_EQ("\xA2\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s,
385 Map(Uint(1), Nint(-1), Bstr(vec), Tstr("hello")).toString());
386
387 EXPECT_EQ("\xA2\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s,
388 Map(1, -1, vec, "hello").toString());
389 }
390
TEST(CompoundValueTest,NestedStructures)391 TEST(CompoundValueTest, NestedStructures) {
392 vector<uint8_t> vec = {3, 2, 1};
393
394 string expectedEncoding =
395 "\xA2\x66\x4F\x75\x74\x65\x72\x31\x82\xA2\x66\x49\x6E\x6E\x65\x72\x31\x18\x63\x66\x49"
396 "\x6E"
397 "\x6E\x65\x72\x32\x43\x03\x02\x01\x63\x66\x6F\x6F\x66\x4F\x75\x74\x65\x72\x32\x0A"s;
398
399 // Do it with explicity-created Items
400 EXPECT_EQ(expectedEncoding,
401 Map(Tstr("Outer1"),
402 Array( //
403 Map(Tstr("Inner1"), Uint(99), Tstr("Inner2"), Bstr(vec)), Tstr("foo")),
404 Tstr("Outer2"), //
405 Uint(10))
406 .toString());
407 EXPECT_EQ(3U, vec.size());
408
409 // Now just use convertible types
410 EXPECT_EQ(expectedEncoding, Map("Outer1",
411 Array(Map("Inner1", 99, //
412 "Inner2", vec),
413 "foo"),
414 "Outer2", 10)
415 .toString());
416 EXPECT_EQ(3U, vec.size());
417
418 // Finally, do it with the .add() method. This is slightly less efficient, but has the
419 // advantage you can build a structure up incrementally, or somewhat fluently if you like.
420 // First, fluently.
421 EXPECT_EQ(expectedEncoding, Map().add("Outer1", Array().add(Map() //
422 .add("Inner1", 99)
423 .add("Inner2", vec))
424 .add("foo"))
425 .add("Outer2", 10)
426 .toString());
427 EXPECT_EQ(3U, vec.size());
428
429 // Next, more incrementally
430 Array arr;
431 arr.add(Map() //
432 .add("Inner1", 99)
433 .add("Inner2", vec))
434 .add("foo");
435 EXPECT_EQ(3U, vec.size());
436
437 Map m;
438 m.add("Outer1", std::move(arr)); // Moving is necessary; Map and Array cannot be copied.
439 m.add("Outer2", 10);
440 auto s = m.toString();
441 EXPECT_EQ(expectedEncoding, s);
442 }
443
TEST(EncodingMethodsTest,AllVariants)444 TEST(EncodingMethodsTest, AllVariants) {
445 Map map;
446 map.add("key1", Array().add(Map() //
447 .add("key_a", 9999999)
448 .add("key_b", std::vector<uint8_t>{0x01, 0x02, 0x03})
449 .add("key_c", std::numeric_limits<uint64_t>::max())
450 .add("key_d", std::numeric_limits<int16_t>::min()))
451 .add("foo"))
452 .add("key2", true)
453 .add("key3", SemanticTag(1, SemanticTag(987654321, "Zhai gana test")));
454
455 std::vector<uint8_t> buf;
456 buf.resize(map.encodedSize());
457
458 EXPECT_EQ(buf.data() + buf.size(), map.encode(buf.data(), buf.data() + buf.size()));
459
460 EXPECT_EQ(buf, map.encode());
461
462 std::vector<uint8_t> buf2;
463 map.encode(std::back_inserter(buf2));
464 EXPECT_EQ(buf, buf2);
465
466 auto iter = buf.begin();
467 map.encode([&](uint8_t c) { EXPECT_EQ(c, *iter++); });
468 }
469
TEST(EncodingMethodsTest,UintWithTooShortBuf)470 TEST(EncodingMethodsTest, UintWithTooShortBuf) {
471 Uint val(100000);
472 vector<uint8_t> buf(val.encodedSize() - 1);
473 EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size()));
474 }
475
TEST(EncodingMethodsTest,TstrWithTooShortBuf)476 TEST(EncodingMethodsTest, TstrWithTooShortBuf) {
477 Tstr val("01234567890123456789012345"s);
478 vector<uint8_t> buf(1);
479 EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size()));
480
481 buf.resize(val.encodedSize() - 1);
482 EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size()));
483 }
484
TEST(EncodingMethodsTest,BstrWithTooShortBuf)485 TEST(EncodingMethodsTest, BstrWithTooShortBuf) {
486 Bstr val("01234567890123456789012345"s);
487 vector<uint8_t> buf(1);
488 EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size()));
489
490 buf.resize(val.encodedSize() - 1);
491 EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size()));
492 }
493
TEST(EncodingMethodsTest,ArrayWithTooShortBuf)494 TEST(EncodingMethodsTest, ArrayWithTooShortBuf) {
495 Array val("a", 5, -100);
496
497 std::vector<uint8_t> buf(val.encodedSize() - 1);
498 EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size()));
499 }
500
TEST(EncodingMethodsTest,MapWithTooShortBuf)501 TEST(EncodingMethodsTest, MapWithTooShortBuf) {
502 Map map;
503 map.add("key1", Array().add(Map() //
504 .add("key_a", 99)
505 .add("key_b", std::vector<uint8_t>{0x01, 0x02, 0x03}))
506 .add("foo"))
507 .add("key2", true);
508
509 std::vector<uint8_t> buf(map.encodedSize() - 1);
510 EXPECT_EQ(nullptr, map.encode(buf.data(), buf.data() + buf.size()));
511 }
512
TEST(EncodingMethodsTest,SemanticTagWithTooShortBuf)513 TEST(EncodingMethodsTest, SemanticTagWithTooShortBuf) {
514 SemanticTag tag(4321, Array().add(Array().add("Qaiyrly kesh!").add("Kesh zharyq!").add("431"))
515 .add(Map().add("kilt_1", 777).add("kilt_2", 999)));
516 std::vector<uint8_t> buf(tag.encodedSize() - 1);
517 EXPECT_EQ(nullptr, tag.encode(buf.data(), buf.data() + buf.size()));
518 }
519
TEST(EqualityTest,Uint)520 TEST(EqualityTest, Uint) {
521 Uint val(99);
522 EXPECT_EQ(val, Uint(99));
523
524 EXPECT_NE(val, Uint(98));
525 EXPECT_NE(val, Nint(-1));
526 EXPECT_NE(val, Tstr("99"));
527 EXPECT_NE(val, Bstr("99"));
528 EXPECT_NE(val, Bool(false));
529 EXPECT_NE(val, Array(99, 1));
530 EXPECT_NE(val, Map(99, 1));
531 EXPECT_NE(val, ViewTstr("99"));
532 EXPECT_NE(val, ViewBstr("99"));
533 }
534
TEST(EqualityTest,Nint)535 TEST(EqualityTest, Nint) {
536 Nint val(-1);
537 EXPECT_EQ(val, Nint(-1));
538
539 EXPECT_NE(val, Uint(99));
540 EXPECT_NE(val, Nint(-4));
541 EXPECT_NE(val, Tstr("99"));
542 EXPECT_NE(val, Bstr("99"));
543 EXPECT_NE(val, Bool(false));
544 EXPECT_NE(val, Array(99));
545 EXPECT_NE(val, Map(99, 1));
546 EXPECT_NE(val, ViewTstr("99"));
547 EXPECT_NE(val, ViewBstr("99"));
548 }
549
TEST(EqualityTest,Tstr)550 TEST(EqualityTest, Tstr) {
551 Tstr val("99");
552 EXPECT_EQ(val, Tstr("99"));
553
554 EXPECT_NE(val, Uint(99));
555 EXPECT_NE(val, Nint(-1));
556 EXPECT_NE(val, Nint(-4));
557 EXPECT_NE(val, Tstr("98"));
558 EXPECT_NE(val, Bstr("99"));
559 EXPECT_NE(val, Bool(false));
560 EXPECT_NE(val, Array(99, 1));
561 EXPECT_NE(val, Map(99, 1));
562 EXPECT_NE(val, ViewTstr("99"));
563 EXPECT_NE(val, ViewBstr("99"));
564 }
565
TEST(EqualityTest,Bstr)566 TEST(EqualityTest, Bstr) {
567 Bstr val("99");
568 EXPECT_EQ(val, Bstr("99"));
569
570 EXPECT_NE(val, Uint(99));
571 EXPECT_NE(val, Nint(-1));
572 EXPECT_NE(val, Nint(-4));
573 EXPECT_NE(val, Tstr("99"));
574 EXPECT_NE(val, Bstr("98"));
575 EXPECT_NE(val, Bool(false));
576 EXPECT_NE(val, Array(99, 1));
577 EXPECT_NE(val, Map(99, 1));
578 EXPECT_NE(val, ViewTstr("99"));
579 EXPECT_NE(val, ViewBstr("99"));
580 }
581
TEST(EqualityTest,Bool)582 TEST(EqualityTest, Bool) {
583 Bool val(false);
584 EXPECT_EQ(val, Bool(false));
585
586 EXPECT_NE(val, Uint(99));
587 EXPECT_NE(val, Nint(-1));
588 EXPECT_NE(val, Nint(-4));
589 EXPECT_NE(val, Tstr("99"));
590 EXPECT_NE(val, Bstr("98"));
591 EXPECT_NE(val, Bool(true));
592 EXPECT_NE(val, Array(99, 1));
593 EXPECT_NE(val, Map(99, 1));
594 EXPECT_NE(val, ViewTstr("99"));
595 EXPECT_NE(val, ViewBstr("98"));
596 }
597
TEST(EqualityTest,Array)598 TEST(EqualityTest, Array) {
599 Array val(99, 1);
600 EXPECT_EQ(val, Array(99, 1));
601
602 EXPECT_NE(val, Uint(99));
603 EXPECT_NE(val, Nint(-1));
604 EXPECT_NE(val, Nint(-4));
605 EXPECT_NE(val, Tstr("99"));
606 EXPECT_NE(val, Bstr("98"));
607 EXPECT_NE(val, Bool(true));
608 EXPECT_NE(val, Array(99, 2));
609 EXPECT_NE(val, Array(98, 1));
610 EXPECT_NE(val, Array(99, 1, 2));
611 EXPECT_NE(val, Map(99, 1));
612 EXPECT_NE(val, ViewTstr("99"));
613 EXPECT_NE(val, ViewBstr("98"));
614 }
615
TEST(EqualityTest,Map)616 TEST(EqualityTest, Map) {
617 Map val(99, 1);
618 EXPECT_EQ(val, Map(99, 1));
619
620 EXPECT_NE(val, Uint(99));
621 EXPECT_NE(val, Nint(-1));
622 EXPECT_NE(val, Nint(-4));
623 EXPECT_NE(val, Tstr("99"));
624 EXPECT_NE(val, Bstr("98"));
625 EXPECT_NE(val, Bool(true));
626 EXPECT_NE(val, Array(99, 1));
627 EXPECT_NE(val, Map(99, 2));
628 EXPECT_NE(val, Map(99, 1, 99, 2));
629 EXPECT_NE(val, ViewTstr("99"));
630 EXPECT_NE(val, ViewBstr("98"));
631 }
632
TEST(EqualityTest,Null)633 TEST(EqualityTest, Null) {
634 Null val;
635 EXPECT_EQ(val, Null());
636
637 EXPECT_NE(val, Uint(99));
638 EXPECT_NE(val, Nint(-1));
639 EXPECT_NE(val, Nint(-4));
640 EXPECT_NE(val, Tstr("99"));
641 EXPECT_NE(val, Bstr("98"));
642 EXPECT_NE(val, Bool(true));
643 EXPECT_NE(val, Array(99, 1));
644 EXPECT_NE(val, Map(99, 2));
645 EXPECT_NE(val, Map(99, 1, 99, 2));
646 EXPECT_NE(val, ViewTstr("99"));
647 EXPECT_NE(val, ViewBstr("98"));
648 }
649
TEST(EqualityTest,SemanticTag)650 TEST(EqualityTest, SemanticTag) {
651 SemanticTag val(215, Bstr("asd"));
652 EXPECT_EQ(val, SemanticTag(215, Bstr("asd")));
653
654 EXPECT_NE(val, Uint(99));
655 EXPECT_NE(val, Nint(-1));
656 EXPECT_NE(val, Nint(-4));
657 EXPECT_NE(val, Tstr("99"));
658 EXPECT_NE(val, Bstr("98"));
659 EXPECT_NE(val, Bool(true));
660 EXPECT_NE(val, Array(99, 1));
661 EXPECT_NE(val, Map(99, 2));
662 EXPECT_NE(val, Null());
663 }
664
TEST(EqualityTest,NestedSemanticTag)665 TEST(EqualityTest, NestedSemanticTag) {
666 SemanticTag val(238238, SemanticTag(215, Bstr("asd")));
667 EXPECT_EQ(val, SemanticTag(238238, SemanticTag(215, Bstr("asd"))));
668
669 EXPECT_NE(val, Uint(99));
670 EXPECT_NE(val, Nint(-1));
671 EXPECT_NE(val, Nint(-4));
672 EXPECT_NE(val, Tstr("99"));
673 EXPECT_NE(val, Bstr("98"));
674 EXPECT_NE(val, Bool(true));
675 EXPECT_NE(val, Array(99, 1));
676 EXPECT_NE(val, Map(99, 2));
677 EXPECT_NE(val, Null());
678 EXPECT_NE(val, ViewTstr("99"));
679 EXPECT_NE(val, ViewBstr("98"));
680 }
681
TEST(EqualityTest,ViewTstr)682 TEST(EqualityTest, ViewTstr) {
683 ViewTstr val("99");
684 EXPECT_EQ(val, ViewTstr("99"));
685
686 EXPECT_NE(val, Uint(99));
687 EXPECT_NE(val, Nint(-1));
688 EXPECT_NE(val, Nint(-4));
689 EXPECT_NE(val, Tstr("99"));
690 EXPECT_NE(val, Bstr("99"));
691 EXPECT_NE(val, Bool(false));
692 EXPECT_NE(val, Array(99, 1));
693 EXPECT_NE(val, Map(99, 1));
694 EXPECT_NE(val, ViewTstr("98"));
695 EXPECT_NE(val, ViewBstr("99"));
696 }
697
TEST(EqualityTest,ViewBstr)698 TEST(EqualityTest, ViewBstr) {
699 ViewBstr val("99");
700 EXPECT_EQ(val, ViewBstr("99"));
701
702 EXPECT_NE(val, Uint(99));
703 EXPECT_NE(val, Nint(-1));
704 EXPECT_NE(val, Nint(-4));
705 EXPECT_NE(val, Tstr("99"));
706 EXPECT_NE(val, Bstr("99"));
707 EXPECT_NE(val, Bool(false));
708 EXPECT_NE(val, Array(99, 1));
709 EXPECT_NE(val, Map(99, 1));
710 EXPECT_NE(val, ViewTstr("99"));
711 EXPECT_NE(val, ViewBstr("98"));
712 }
713
TEST(ConvertTest,Uint)714 TEST(ConvertTest, Uint) {
715 unique_ptr<Item> item = details::makeItem(10);
716
717 EXPECT_EQ(cppbor::UINT, item->type());
718 EXPECT_NE(nullptr, item->asInt());
719 EXPECT_NE(nullptr, item->asUint());
720 EXPECT_EQ(nullptr, item->asNint());
721 EXPECT_EQ(nullptr, item->asTstr());
722 EXPECT_EQ(nullptr, item->asBstr());
723 EXPECT_EQ(nullptr, item->asSimple());
724 EXPECT_EQ(nullptr, item->asBool());
725 EXPECT_EQ(nullptr, item->asNull());
726 EXPECT_EQ(nullptr, item->asMap());
727 EXPECT_EQ(nullptr, item->asArray());
728 EXPECT_EQ(nullptr, item->asViewTstr());
729 EXPECT_EQ(nullptr, item->asViewBstr());
730
731 EXPECT_EQ(10, item->asInt()->value());
732 EXPECT_EQ(10, item->asUint()->value());
733 }
734
TEST(ConvertTest,Nint)735 TEST(ConvertTest, Nint) {
736 unique_ptr<Item> item = details::makeItem(-10);
737
738 EXPECT_EQ(NINT, item->type());
739 EXPECT_NE(nullptr, item->asInt());
740 EXPECT_EQ(nullptr, item->asUint());
741 EXPECT_NE(nullptr, item->asNint());
742 EXPECT_EQ(nullptr, item->asTstr());
743 EXPECT_EQ(nullptr, item->asBstr());
744 EXPECT_EQ(nullptr, item->asSimple());
745 EXPECT_EQ(nullptr, item->asBool());
746 EXPECT_EQ(nullptr, item->asNull());
747 EXPECT_EQ(nullptr, item->asMap());
748 EXPECT_EQ(nullptr, item->asArray());
749 EXPECT_EQ(nullptr, item->asViewTstr());
750 EXPECT_EQ(nullptr, item->asViewBstr());
751
752 EXPECT_EQ(-10, item->asInt()->value());
753 EXPECT_EQ(-10, item->asNint()->value());
754 }
755
TEST(ConvertTest,Tstr)756 TEST(ConvertTest, Tstr) {
757 unique_ptr<Item> item = details::makeItem("hello");
758
759 EXPECT_EQ(TSTR, item->type());
760 EXPECT_EQ(nullptr, item->asInt());
761 EXPECT_EQ(nullptr, item->asUint());
762 EXPECT_EQ(nullptr, item->asNint());
763 EXPECT_NE(nullptr, item->asTstr());
764 EXPECT_EQ(nullptr, item->asBstr());
765 EXPECT_EQ(nullptr, item->asSimple());
766 EXPECT_EQ(nullptr, item->asBool());
767 EXPECT_EQ(nullptr, item->asNull());
768 EXPECT_EQ(nullptr, item->asMap());
769 EXPECT_EQ(nullptr, item->asArray());
770 EXPECT_EQ(nullptr, item->asViewTstr());
771 EXPECT_EQ(nullptr, item->asViewBstr());
772
773 EXPECT_EQ("hello"s, item->asTstr()->value());
774 }
775
TEST(ConvertTest,Bstr)776 TEST(ConvertTest, Bstr) {
777 vector<uint8_t> vec{0x23, 0x24, 0x22};
778 unique_ptr<Item> item = details::makeItem(vec);
779
780 EXPECT_EQ(BSTR, item->type());
781 EXPECT_EQ(nullptr, item->asInt());
782 EXPECT_EQ(nullptr, item->asUint());
783 EXPECT_EQ(nullptr, item->asNint());
784 EXPECT_EQ(nullptr, item->asTstr());
785 EXPECT_NE(nullptr, item->asBstr());
786 EXPECT_EQ(nullptr, item->asSimple());
787 EXPECT_EQ(nullptr, item->asBool());
788 EXPECT_EQ(nullptr, item->asNull());
789 EXPECT_EQ(nullptr, item->asMap());
790 EXPECT_EQ(nullptr, item->asArray());
791 EXPECT_EQ(nullptr, item->asViewTstr());
792 EXPECT_EQ(nullptr, item->asViewBstr());
793
794 EXPECT_EQ(vec, item->asBstr()->value());
795 }
796
TEST(ConvertTest,Bool)797 TEST(ConvertTest, Bool) {
798 unique_ptr<Item> item = details::makeItem(false);
799
800 EXPECT_EQ(SIMPLE, item->type());
801 EXPECT_EQ(nullptr, item->asInt());
802 EXPECT_EQ(nullptr, item->asUint());
803 EXPECT_EQ(nullptr, item->asNint());
804 EXPECT_EQ(nullptr, item->asTstr());
805 EXPECT_EQ(nullptr, item->asBstr());
806 EXPECT_NE(nullptr, item->asSimple());
807 EXPECT_NE(nullptr, item->asBool());
808 EXPECT_EQ(nullptr, item->asNull());
809 EXPECT_EQ(nullptr, item->asMap());
810 EXPECT_EQ(nullptr, item->asArray());
811 EXPECT_EQ(nullptr, item->asViewTstr());
812 EXPECT_EQ(nullptr, item->asViewBstr());
813
814 EXPECT_EQ(cppbor::BOOLEAN, item->asSimple()->simpleType());
815 EXPECT_NE(nullptr, item->asBool());
816 EXPECT_NE(nullptr, item->asSimple()->asBool());
817 EXPECT_EQ(nullptr, item->asNull());
818 EXPECT_EQ(nullptr, item->asSimple()->asNull());
819
820 EXPECT_FALSE(item->asBool()->value());
821 EXPECT_FALSE(item->asSimple()->asBool()->value());
822 }
823
TEST(ConvertTest,Map)824 TEST(ConvertTest, Map) {
825 unique_ptr<Item> item(new Map);
826
827 EXPECT_EQ(MAP, item->type());
828 EXPECT_EQ(nullptr, item->asInt());
829 EXPECT_EQ(nullptr, item->asUint());
830 EXPECT_EQ(nullptr, item->asNint());
831 EXPECT_EQ(nullptr, item->asTstr());
832 EXPECT_EQ(nullptr, item->asBstr());
833 EXPECT_EQ(nullptr, item->asSimple());
834 EXPECT_EQ(nullptr, item->asBool());
835 EXPECT_EQ(nullptr, item->asNull());
836 EXPECT_NE(nullptr, item->asMap());
837 EXPECT_EQ(nullptr, item->asArray());
838 EXPECT_EQ(nullptr, item->asViewTstr());
839 EXPECT_EQ(nullptr, item->asViewBstr());
840
841 EXPECT_EQ(0U, item->asMap()->size());
842 }
843
TEST(ConvertTest,Array)844 TEST(ConvertTest, Array) {
845 unique_ptr<Item> item(new Array);
846
847 EXPECT_EQ(ARRAY, item->type());
848 EXPECT_EQ(nullptr, item->asInt());
849 EXPECT_EQ(nullptr, item->asUint());
850 EXPECT_EQ(nullptr, item->asNint());
851 EXPECT_EQ(nullptr, item->asTstr());
852 EXPECT_EQ(nullptr, item->asBstr());
853 EXPECT_EQ(nullptr, item->asSimple());
854 EXPECT_EQ(nullptr, item->asBool());
855 EXPECT_EQ(nullptr, item->asNull());
856 EXPECT_EQ(nullptr, item->asMap());
857 EXPECT_NE(nullptr, item->asArray());
858 EXPECT_EQ(nullptr, item->asViewTstr());
859 EXPECT_EQ(nullptr, item->asViewBstr());
860
861 EXPECT_EQ(0U, item->asArray()->size());
862 }
863
TEST(ConvertTest,SemanticTag)864 TEST(ConvertTest, SemanticTag) {
865 unique_ptr<Item> item(new SemanticTag(10, "DSA"));
866
867 EXPECT_EQ(TSTR, item->type());
868 EXPECT_EQ(nullptr, item->asInt());
869 EXPECT_EQ(nullptr, item->asUint());
870 EXPECT_EQ(nullptr, item->asNint());
871 EXPECT_EQ(nullptr, item->asBstr());
872 EXPECT_EQ(nullptr, item->asSimple());
873 EXPECT_EQ(nullptr, item->asBool());
874 EXPECT_EQ(nullptr, item->asNull());
875 EXPECT_EQ(nullptr, item->asMap());
876 EXPECT_EQ(nullptr, item->asArray());
877 EXPECT_EQ(nullptr, item->asViewTstr());
878 EXPECT_EQ(nullptr, item->asViewBstr());
879
880 // Both asTstr() (the contained type) and asSemanticTag() return non-null.
881 EXPECT_NE(nullptr, item->asTstr());
882 EXPECT_NE(nullptr, item->asSemanticTag());
883
884 // asTtr() and asSemanticTag() actually return different objects.
885 EXPECT_NE(static_cast<Item*>(item->asTstr()), static_cast<Item*>(item->asSemanticTag()));
886
887 EXPECT_EQ(1U, item->asSemanticTag()->size());
888 EXPECT_EQ("DSA", item->asTstr()->value());
889
890 EXPECT_EQ(1U, item->semanticTagCount());
891 EXPECT_EQ(10U, item->semanticTag());
892 }
893
TEST(ConvertTest,NestedSemanticTag)894 TEST(ConvertTest, NestedSemanticTag) {
895 unique_ptr<Item> item(new SemanticTag(40, new SemanticTag(10, "DSA")));
896
897 EXPECT_EQ(TSTR, item->type());
898 EXPECT_EQ(nullptr, item->asInt());
899 EXPECT_EQ(nullptr, item->asUint());
900 EXPECT_EQ(nullptr, item->asNint());
901 EXPECT_EQ(nullptr, item->asBstr());
902 EXPECT_EQ(nullptr, item->asSimple());
903 EXPECT_EQ(nullptr, item->asBool());
904 EXPECT_EQ(nullptr, item->asNull());
905 EXPECT_EQ(nullptr, item->asMap());
906 EXPECT_EQ(nullptr, item->asArray());
907 EXPECT_EQ(nullptr, item->asViewTstr());
908 EXPECT_EQ(nullptr, item->asViewBstr());
909
910 // Both asTstr() (the contained type) and asSemanticTag() return non-null.
911 EXPECT_NE(nullptr, item->asTstr());
912 EXPECT_NE(nullptr, item->asSemanticTag());
913
914 // asTtr() and asSemanticTag() actually return different objects. Note that there's no way to
915 // get a pointer to the "inner" SemanticTag object. There shouldn't be any need to.
916 EXPECT_NE(static_cast<Item*>(item->asTstr()), static_cast<Item*>(item->asSemanticTag()));
917
918 EXPECT_EQ(1U, item->asSemanticTag()->size());
919 EXPECT_EQ("DSA", item->asTstr()->value());
920
921 EXPECT_EQ(2U, item->semanticTagCount());
922 EXPECT_EQ(10U, item->semanticTag(0));
923 EXPECT_EQ(40U, item->semanticTag(1));
924 }
925
TEST(ConvertTest,Null)926 TEST(ConvertTest, Null) {
927 unique_ptr<Item> item(new Null);
928
929 EXPECT_EQ(SIMPLE, item->type());
930 EXPECT_EQ(nullptr, item->asInt());
931 EXPECT_EQ(nullptr, item->asUint());
932 EXPECT_EQ(nullptr, item->asNint());
933 EXPECT_EQ(nullptr, item->asTstr());
934 EXPECT_EQ(nullptr, item->asBstr());
935 EXPECT_NE(nullptr, item->asSimple());
936 EXPECT_EQ(nullptr, item->asBool());
937 EXPECT_NE(nullptr, item->asNull());
938 EXPECT_EQ(nullptr, item->asMap());
939 EXPECT_EQ(nullptr, item->asArray());
940 EXPECT_EQ(nullptr, item->asViewTstr());
941 EXPECT_EQ(nullptr, item->asViewBstr());
942
943 EXPECT_EQ(NULL_T, item->asSimple()->simpleType());
944 EXPECT_EQ(nullptr, item->asBool());
945 EXPECT_EQ(nullptr, item->asSimple()->asBool());
946 EXPECT_NE(nullptr, item->asNull());
947 EXPECT_NE(nullptr, item->asSimple()->asNull());
948 }
949
TEST(ConvertTest,ViewTstr)950 TEST(ConvertTest, ViewTstr) {
951 unique_ptr<Item> item = details::makeItem(ViewTstr("hello"));
952
953 EXPECT_EQ(TSTR, item->type());
954 EXPECT_EQ(nullptr, item->asInt());
955 EXPECT_EQ(nullptr, item->asUint());
956 EXPECT_EQ(nullptr, item->asNint());
957 EXPECT_EQ(nullptr, item->asTstr());
958 EXPECT_EQ(nullptr, item->asBstr());
959 EXPECT_EQ(nullptr, item->asSimple());
960 EXPECT_EQ(nullptr, item->asBool());
961 EXPECT_EQ(nullptr, item->asNull());
962 EXPECT_EQ(nullptr, item->asMap());
963 EXPECT_EQ(nullptr, item->asArray());
964 EXPECT_NE(nullptr, item->asViewTstr());
965 EXPECT_EQ(nullptr, item->asViewBstr());
966
967 EXPECT_EQ("hello"sv, item->asViewTstr()->view());
968 }
969
TEST(ConvertTest,ViewBstr)970 TEST(ConvertTest, ViewBstr) {
971 array<uint8_t, 3> vec{0x23, 0x24, 0x22};
972 basic_string_view<uint8_t> sv(vec.data(), vec.size());
973 unique_ptr<Item> item = details::makeItem(ViewBstr(sv));
974
975 EXPECT_EQ(BSTR, item->type());
976 EXPECT_EQ(nullptr, item->asInt());
977 EXPECT_EQ(nullptr, item->asUint());
978 EXPECT_EQ(nullptr, item->asNint());
979 EXPECT_EQ(nullptr, item->asTstr());
980 EXPECT_EQ(nullptr, item->asBstr());
981 EXPECT_EQ(nullptr, item->asSimple());
982 EXPECT_EQ(nullptr, item->asBool());
983 EXPECT_EQ(nullptr, item->asNull());
984 EXPECT_EQ(nullptr, item->asMap());
985 EXPECT_EQ(nullptr, item->asArray());
986 EXPECT_EQ(nullptr, item->asViewTstr());
987 EXPECT_NE(nullptr, item->asViewBstr());
988
989 EXPECT_EQ(sv, item->asViewBstr()->view());
990 }
991
TEST(CloningTest,Uint)992 TEST(CloningTest, Uint) {
993 Uint item(10);
994 auto clone = item.clone();
995 EXPECT_EQ(clone->type(), cppbor::UINT);
996 EXPECT_NE(clone->asUint(), nullptr);
997 EXPECT_EQ(item, *clone->asUint());
998 EXPECT_EQ(*clone->asUint(), Uint(10));
999 }
1000
TEST(CloningTest,Nint)1001 TEST(CloningTest, Nint) {
1002 Nint item(-1000000);
1003 auto clone = item.clone();
1004 EXPECT_EQ(clone->type(), NINT);
1005 EXPECT_NE(clone->asNint(), nullptr);
1006 EXPECT_EQ(item, *clone->asNint());
1007 EXPECT_EQ(*clone->asNint(), Nint(-1000000));
1008 }
1009
TEST(CloningTest,Tstr)1010 TEST(CloningTest, Tstr) {
1011 Tstr item("qwertyasdfgh");
1012 auto clone = item.clone();
1013 EXPECT_EQ(clone->type(), TSTR);
1014 EXPECT_NE(clone->asTstr(), nullptr);
1015 EXPECT_EQ(item, *clone->asTstr());
1016 EXPECT_EQ(*clone->asTstr(), Tstr("qwertyasdfgh"));
1017 }
1018
TEST(CloningTest,Bstr)1019 TEST(CloningTest, Bstr) {
1020 Bstr item(std::vector<uint8_t>{1, 2, 3, 255, 0});
1021 auto clone = item.clone();
1022 EXPECT_EQ(clone->type(), BSTR);
1023 EXPECT_NE(clone->asBstr(), nullptr);
1024 EXPECT_EQ(item, *clone->asBstr());
1025 EXPECT_EQ(*clone->asBstr(), Bstr(std::vector<uint8_t>{1, 2, 3, 255, 0}));
1026 }
1027
TEST(CloningTest,Array)1028 TEST(CloningTest, Array) {
1029 Array item(-1000000, 22222222, "item", Map(1, 2, 4, Array(1, "das", true, nullptr)),
1030 SemanticTag(16, "DATA")),
1031 copy(-1000000, 22222222, "item", Map(1, 2, 4, Array(1, "das", true, nullptr)),
1032 SemanticTag(16, "DATA"));
1033 auto clone = item.clone();
1034 EXPECT_EQ(clone->type(), ARRAY);
1035 EXPECT_NE(clone->asArray(), nullptr);
1036 EXPECT_EQ(item, *clone->asArray());
1037 EXPECT_EQ(*clone->asArray(), copy);
1038 }
1039
TEST(CloningTest,Map)1040 TEST(CloningTest, Map) {
1041 Map item("key", Array("value1", "value2", 3), 15, Null(), -5, 45),
1042 copy("key", Array("value1", "value2", 3), 15, Null(), -5, 45);
1043 auto clone = item.clone();
1044 EXPECT_EQ(clone->type(), MAP);
1045 EXPECT_NE(clone->asMap(), nullptr);
1046 EXPECT_EQ(item, *clone->asMap());
1047 EXPECT_EQ(*clone->asMap(), copy);
1048 }
1049
TEST(CloningTest,Bool)1050 TEST(CloningTest, Bool) {
1051 Bool item(true);
1052 auto clone = item.clone();
1053 EXPECT_EQ(clone->type(), SIMPLE);
1054 EXPECT_NE(clone->asSimple(), nullptr);
1055 EXPECT_EQ(clone->asSimple()->simpleType(), cppbor::BOOLEAN);
1056 EXPECT_NE(clone->asBool(), nullptr);
1057 EXPECT_NE(clone->asSimple()->asBool(), nullptr);
1058 EXPECT_EQ(item, *clone->asBool());
1059 EXPECT_EQ(item, *clone->asSimple()->asBool());
1060 EXPECT_EQ(*clone->asBool(), Bool(true));
1061 EXPECT_EQ(*clone->asSimple()->asBool(), Bool(true));
1062 }
1063
TEST(CloningTest,Null)1064 TEST(CloningTest, Null) {
1065 Null item;
1066 auto clone = item.clone();
1067 EXPECT_EQ(clone->type(), SIMPLE);
1068 EXPECT_NE(clone->asSimple(), nullptr);
1069 EXPECT_EQ(clone->asSimple()->simpleType(), NULL_T);
1070 EXPECT_NE(clone->asSimple()->asNull(), nullptr);
1071 EXPECT_EQ(item, *clone->asSimple()->asNull());
1072 EXPECT_EQ(*clone->asSimple()->asNull(), Null());
1073 }
1074
TEST(CloningTest,SemanticTag)1075 TEST(CloningTest, SemanticTag) {
1076 SemanticTag item(96, Array(1, 2, 3, "entry", Map("key", "value")));
1077 SemanticTag copy(96, Array(1, 2, 3, "entry", Map("key", "value")));
1078
1079 auto clone = item.clone();
1080 EXPECT_EQ(clone->type(), ARRAY);
1081 EXPECT_NE(clone->asSemanticTag(), nullptr);
1082 EXPECT_EQ(item, *clone->asSemanticTag());
1083 EXPECT_EQ(*clone->asSemanticTag(), copy);
1084 }
1085
TEST(CloningTest,NestedSemanticTag)1086 TEST(CloningTest, NestedSemanticTag) {
1087 SemanticTag item(20, //
1088 SemanticTag(30, //
1089 SemanticTag(96, //
1090 Array(1, 2, 3, "entry", Map("key", "value")))));
1091 SemanticTag copy(20, //
1092 SemanticTag(30, //
1093 SemanticTag(96, //
1094 Array(1, 2, 3, "entry", Map("key", "value")))));
1095
1096 auto clone = item.clone();
1097 EXPECT_EQ(clone->type(), ARRAY);
1098 EXPECT_NE(clone->asSemanticTag(), nullptr);
1099 EXPECT_EQ(item, *clone->asSemanticTag());
1100 EXPECT_EQ(*clone->asSemanticTag(), copy);
1101 }
1102
TEST(CloningTest,ViewTstr)1103 TEST(CloningTest, ViewTstr) {
1104 ViewTstr item("qwertyasdfgh");
1105 auto clone = item.clone();
1106 EXPECT_EQ(clone->type(), TSTR);
1107 EXPECT_NE(clone->asViewTstr(), nullptr);
1108 EXPECT_EQ(item, *clone->asViewTstr());
1109 EXPECT_EQ(*clone->asViewTstr(), ViewTstr("qwertyasdfgh"));
1110 }
1111
TEST(CloningTest,ViewBstr)1112 TEST(CloningTest, ViewBstr) {
1113 array<uint8_t, 5> vec{1, 2, 3, 255, 0};
1114 basic_string_view<uint8_t> sv(vec.data(), vec.size());
1115 ViewBstr item(sv);
1116 auto clone = item.clone();
1117 EXPECT_EQ(clone->type(), BSTR);
1118 EXPECT_NE(clone->asViewBstr(), nullptr);
1119 EXPECT_EQ(item, *clone->asViewBstr());
1120 EXPECT_EQ(*clone->asViewBstr(), ViewBstr(sv));
1121 }
1122
TEST(PrettyPrintingTest,NestedSemanticTag)1123 TEST(PrettyPrintingTest, NestedSemanticTag) {
1124 SemanticTag item(20, //
1125 SemanticTag(30, //
1126 SemanticTag(96, //
1127 Array(1, 2, 3, "entry", Map("key", "value")))));
1128 EXPECT_EQ(prettyPrint(&item),
1129 "tag 20 tag 30 tag 96 [\n"
1130 " 1,\n"
1131 " 2,\n"
1132 " 3,\n"
1133 " 'entry',\n"
1134 " {\n"
1135 " 'key' : 'value',\n"
1136 " },\n"
1137 "]");
1138 }
1139
TEST(MapCanonicalizationTest,CanonicalizationTest)1140 TEST(MapCanonicalizationTest, CanonicalizationTest) {
1141 Map map;
1142 map.add("hello", 1)
1143 .add("h", 1)
1144 .add(1, 1)
1145 .add(-4, 1)
1146 .add(-5, 1)
1147 .add(2, 1)
1148 .add("hellp", 1)
1149 .add(254, 1)
1150 .add(27, 1);
1151
1152 EXPECT_EQ(prettyPrint(&map),
1153 "{\n"
1154 " 'hello' : 1,\n"
1155 " 'h' : 1,\n"
1156 " 1 : 1,\n"
1157 " -4 : 1,\n"
1158 " -5 : 1,\n"
1159 " 2 : 1,\n"
1160 " 'hellp' : 1,\n"
1161 " 254 : 1,\n"
1162 " 27 : 1,\n"
1163 "}");
1164
1165 map.canonicalize();
1166
1167 // Canonically ordered by key encoding.
1168 EXPECT_EQ(prettyPrint(&map),
1169 "{\n"
1170 " 1 : 1,\n"
1171 " 2 : 1,\n"
1172 " -4 : 1,\n"
1173 " -5 : 1,\n"
1174 " 27 : 1,\n"
1175 " 254 : 1,\n"
1176 " 'h' : 1,\n"
1177 " 'hello' : 1,\n"
1178 " 'hellp' : 1,\n"
1179 "}");
1180 }
1181
TEST(MapCanonicalizationTest,DecanonicalizationTest)1182 TEST(MapCanonicalizationTest, DecanonicalizationTest) {
1183 Map map;
1184 map.add("hello", 1)
1185 .add("h", 1)
1186 .add(1, 1)
1187 .add(-4, 1)
1188 .add(-5, 1)
1189 .add(2, 1)
1190 .add("hellp", 1)
1191 .add(254, 1)
1192 .add(27, 1);
1193
1194 EXPECT_FALSE(map.isCanonical());
1195 map.canonicalize();
1196 EXPECT_TRUE(map.isCanonical());
1197
1198 /*
1199 * Any operation that could potentially mutate the contents of the map should mark it as
1200 * non-canonical. This includes getting non-const iterators or using the non-const [] operator.
1201 */
1202
1203 map.begin();
1204 EXPECT_FALSE(map.isCanonical());
1205
1206 map.canonicalize();
1207 EXPECT_TRUE(map.isCanonical());
1208
1209 map.end(); // Non-const map.end() invalidates canonicalization.
1210 EXPECT_FALSE(map.isCanonical());
1211
1212 map.canonicalize();
1213 EXPECT_TRUE(map.isCanonical());
1214
1215 map[0]; // Non-const map.operator[]() invalidates canonicalization.
1216 EXPECT_FALSE(map.isCanonical());
1217 }
1218
TEST(MapCanonicalizationTest,RecursiveTest)1219 TEST(MapCanonicalizationTest, RecursiveTest) {
1220 auto map = Map() //
1221 .add("hello", 1)
1222 .add("h", 1)
1223 .add(1, 1)
1224 .add(-4, Array( //
1225 2, 1,
1226 Map() //
1227 .add("b", 1)
1228 .add(Map() //
1229 .add("hello", "goodbye")
1230 .add(1, 9)
1231 .add(0, 3),
1232 Map() //
1233 .add("b", 1)
1234 .add("a", 2))))
1235 .add(-5, 1)
1236 .add(2, 1)
1237 .add("hellp", 1)
1238 .add(254, 1)
1239 .add(27, 1);
1240
1241 EXPECT_EQ(prettyPrint(&map),
1242 "{\n"
1243 " 'hello' : 1,\n"
1244 " 'h' : 1,\n"
1245 " 1 : 1,\n"
1246 " -4 : [\n"
1247 " 2,\n"
1248 " 1,\n"
1249 " {\n"
1250 " 'b' : 1,\n"
1251 " {\n"
1252 " 'hello' : 'goodbye',\n"
1253 " 1 : 9,\n"
1254 " 0 : 3,\n"
1255 " } : {\n"
1256 " 'b' : 1,\n"
1257 " 'a' : 2,\n"
1258 " },\n"
1259 " },\n"
1260 " ],\n"
1261 " -5 : 1,\n"
1262 " 2 : 1,\n"
1263 " 'hellp' : 1,\n"
1264 " 254 : 1,\n"
1265 " 27 : 1,\n"
1266 "}");
1267
1268 map.canonicalize(true /* recurse */);
1269
1270 EXPECT_EQ(prettyPrint(&map),
1271 "{\n"
1272 " 1 : 1,\n"
1273 " 2 : 1,\n"
1274 " -4 : [\n"
1275 " 2,\n"
1276 " 1,\n"
1277 " {\n"
1278 " 'b' : 1,\n"
1279 " {\n"
1280 " 0 : 3,\n"
1281 " 1 : 9,\n"
1282 " 'hello' : 'goodbye',\n"
1283 " } : {\n"
1284 " 'a' : 2,\n"
1285 " 'b' : 1,\n"
1286 " },\n"
1287 " },\n"
1288 " ],\n"
1289 " -5 : 1,\n"
1290 " 27 : 1,\n"
1291 " 254 : 1,\n"
1292 " 'h' : 1,\n"
1293 " 'hello' : 1,\n"
1294 " 'hellp' : 1,\n"
1295 "}");
1296 }
1297
1298 class MockParseClient : public ParseClient {
1299 public:
1300 MOCK_METHOD4(item, ParseClient*(std::unique_ptr<Item>& item, const uint8_t* hdrBegin,
1301 const uint8_t* valueBegin, const uint8_t* end));
1302 MOCK_METHOD4(itemEnd, ParseClient*(std::unique_ptr<Item>& item, const uint8_t* hdrBegin,
1303 const uint8_t* valueBegin, const uint8_t* end));
1304 MOCK_METHOD2(error, void(const uint8_t* position, const std::string& errorMessage));
1305 };
1306
1307 MATCHER_P(IsType, value, std::string("Type ") + (negation ? "doesn't match" : "matches")) {
1308 return arg->type() == value;
1309 }
1310
1311 MATCHER_P(MatchesItem, value, "") {
1312 return arg && *arg == value;
1313 }
1314
1315 MATCHER_P(IsArrayOfSize, value, "") {
1316 return arg->type() == ARRAY && arg->asArray()->size() == value;
1317 }
1318
1319 MATCHER_P(IsSemanticTagOfValue, value, "") {
1320 return arg->semanticTagCount() == 1 && arg->semanticTag() == value;
1321 }
1322
1323 MATCHER_P(IsMapOfSize, value, "") {
1324 return arg->type() == MAP && arg->asMap()->size() == value;
1325 }
1326
TEST(StreamParseTest,Uint)1327 TEST(StreamParseTest, Uint) {
1328 MockParseClient mpc;
1329
1330 Uint val(100);
1331 auto encoded = val.encode();
1332 uint8_t* encBegin = encoded.data();
1333 uint8_t* encEnd = encoded.data() + encoded.size();
1334
1335 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc));
1336 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1337 EXPECT_CALL(mpc, error(_, _)).Times(0);
1338
1339 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1340 }
1341
TEST(StreamParseTest,Nint)1342 TEST(StreamParseTest, Nint) {
1343 MockParseClient mpc;
1344
1345 Nint val(-10);
1346 auto encoded = val.encode();
1347 uint8_t* encBegin = encoded.data();
1348 uint8_t* encEnd = encoded.data() + encoded.size();
1349
1350 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc));
1351
1352 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1353 EXPECT_CALL(mpc, error(_, _)).Times(0);
1354
1355 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1356 }
1357
TEST(StreamParseTest,Bool)1358 TEST(StreamParseTest, Bool) {
1359 MockParseClient mpc;
1360
1361 Bool val(true);
1362 auto encoded = val.encode();
1363 uint8_t* encBegin = encoded.data();
1364 uint8_t* encEnd = encoded.data() + encoded.size();
1365
1366 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc));
1367 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1368 EXPECT_CALL(mpc, error(_, _)).Times(0);
1369
1370 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1371 }
1372
TEST(StreamParseTest,Null)1373 TEST(StreamParseTest, Null) {
1374 MockParseClient mpc;
1375
1376 Null val;
1377 auto encoded = val.encode();
1378 uint8_t* encBegin = encoded.data();
1379 uint8_t* encEnd = encoded.data() + encoded.size();
1380
1381 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc));
1382 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1383 EXPECT_CALL(mpc, error(_, _)).Times(0);
1384
1385 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1386 }
1387
TEST(StreamParseTest,Tstr)1388 TEST(StreamParseTest, Tstr) {
1389 MockParseClient mpc;
1390
1391 Tstr val("Hello");
1392 auto encoded = val.encode();
1393 uint8_t* encBegin = encoded.data();
1394 uint8_t* encEnd = encoded.data() + encoded.size();
1395
1396 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encBegin + 1, encEnd)).WillOnce(Return(&mpc));
1397 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1398 EXPECT_CALL(mpc, error(_, _)).Times(0);
1399
1400 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1401 }
1402
TEST(StreamParseTest,Bstr)1403 TEST(StreamParseTest, Bstr) {
1404 MockParseClient mpc;
1405
1406 Bstr val("Hello");
1407 auto encoded = val.encode();
1408 uint8_t* encBegin = encoded.data();
1409 uint8_t* encEnd = encoded.data() + encoded.size();
1410
1411 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encBegin + 1, encEnd)).WillOnce(Return(&mpc));
1412 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1413 EXPECT_CALL(mpc, error(_, _)).Times(0);
1414
1415 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1416 }
1417
TEST(StreamParseTest,Array)1418 TEST(StreamParseTest, Array) {
1419 MockParseClient mpc;
1420
1421 Array val("Hello", 4, Array(-9, "Goodbye"), std::numeric_limits<uint64_t>::max());
1422 ASSERT_NE(val[2]->asArray(), nullptr);
1423 const Array& interior = *(val[2]->asArray());
1424 auto encoded = val.encode();
1425 uint8_t* encBegin = encoded.data();
1426 uint8_t* encEnd = encoded.data() + encoded.size();
1427
1428 {
1429 InSequence s;
1430 const uint8_t* pos = encBegin;
1431 EXPECT_CALL(mpc, item(IsArrayOfSize(val.size()), pos, pos + 1, pos + 1))
1432 .WillOnce(Return(&mpc));
1433 ++pos;
1434 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[0])), pos, pos + 1, pos + 6))
1435 .WillOnce(Return(&mpc));
1436 pos += 6;
1437 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[1])), pos, pos + 1, pos + 1))
1438 .WillOnce(Return(&mpc));
1439 ++pos;
1440 const uint8_t* innerArrayBegin = pos;
1441 EXPECT_CALL(mpc, item(IsArrayOfSize(interior.size()), pos, pos + 1, pos + 1))
1442 .WillOnce(Return(&mpc));
1443 ++pos;
1444 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[0])), pos, pos + 1, pos + 1))
1445 .WillOnce(Return(&mpc));
1446 ++pos;
1447 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[1])), pos, pos + 1, pos + 8))
1448 .WillOnce(Return(&mpc));
1449 pos += 8;
1450 EXPECT_CALL(mpc, itemEnd(IsArrayOfSize(interior.size()), innerArrayBegin,
1451 innerArrayBegin + 1, pos))
1452 .WillOnce(Return(&mpc));
1453 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[3])), pos, pos + 9, pos + 9))
1454 .WillOnce(Return(&mpc));
1455 EXPECT_CALL(mpc, itemEnd(IsArrayOfSize(val.size()), encBegin, encBegin + 1, encEnd))
1456 .WillOnce(Return(&mpc));
1457 }
1458
1459 EXPECT_CALL(mpc, error(_, _)) //
1460 .Times(0);
1461
1462 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1463 }
1464
TEST(StreamParseTest,SemanticTag)1465 TEST(StreamParseTest, SemanticTag) {
1466 MockParseClient mpc;
1467 SemanticTag val(15, Array(-5, "Hi"));
1468 auto encoded = val.encode();
1469 ASSERT_NE(val.asArray(), nullptr);
1470 const Array& array = *(val.asArray());
1471 uint8_t* encBegin = encoded.data();
1472 uint8_t* encEnd = encoded.data() + encoded.size();
1473
1474 {
1475 InSequence s;
1476 const uint8_t* pos = encBegin;
1477 EXPECT_CALL(mpc, item(IsSemanticTagOfValue(val.semanticTag()), pos, pos + 1, pos + 1))
1478 .WillOnce(Return(&mpc));
1479 ++pos;
1480 const uint8_t* innerArrayBegin = pos;
1481 EXPECT_CALL(mpc, item(IsArrayOfSize(array.size()), pos, pos + 1, pos + 1))
1482 .WillOnce(Return(&mpc));
1483 ++pos;
1484 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*array[0])), pos, pos + 1, pos + 1))
1485 .WillOnce(Return(&mpc));
1486 ++pos;
1487 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*array[1])), pos, pos + 1, pos + 3))
1488 .WillOnce(Return(&mpc));
1489 pos += 3;
1490 EXPECT_CALL(mpc,
1491 itemEnd(IsArrayOfSize(array.size()), innerArrayBegin, innerArrayBegin + 1, pos))
1492 .WillOnce(Return(&mpc));
1493 EXPECT_CALL(mpc, itemEnd(IsSemanticTagOfValue(val.semanticTag()), encBegin, encBegin + 1,
1494 encEnd))
1495 .WillOnce(Return(&mpc));
1496 }
1497
1498 EXPECT_CALL(mpc, error(_, _)) //
1499 .Times(0);
1500 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1501 }
1502
TEST(StreamParseTest,Map)1503 TEST(StreamParseTest, Map) {
1504 MockParseClient mpc;
1505
1506 Map val("Hello", 4, Array(-9, "Goodbye"), std::numeric_limits<uint64_t>::max());
1507 ASSERT_NE(val[1].first->asArray(), nullptr);
1508 const Array& interior = *(val[1].first->asArray());
1509 auto encoded = val.encode();
1510 uint8_t* encBegin = encoded.data();
1511 uint8_t* encEnd = encoded.data() + encoded.size();
1512
1513 {
1514 InSequence s;
1515 const uint8_t* pos = encBegin;
1516 EXPECT_CALL(mpc, item(_, pos, pos + 1, pos + 1)).WillOnce(Return(&mpc));
1517 ++pos;
1518 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[0].first)), pos, pos + 1, pos + 6))
1519 .WillOnce(Return(&mpc));
1520 pos += 6;
1521 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[0].second)), pos, pos + 1, pos + 1))
1522 .WillOnce(Return(&mpc));
1523 ++pos;
1524 const uint8_t* innerArrayBegin = pos;
1525 EXPECT_CALL(mpc, item(IsArrayOfSize(interior.size()), pos, pos + 1, pos + 1))
1526 .WillOnce(Return(&mpc));
1527 ++pos;
1528 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[0])), pos, pos + 1, pos + 1))
1529 .WillOnce(Return(&mpc));
1530 ++pos;
1531 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[1])), pos, pos + 1, pos + 8))
1532 .WillOnce(Return(&mpc));
1533 pos += 8;
1534 EXPECT_CALL(mpc, itemEnd(IsArrayOfSize(interior.size()), innerArrayBegin,
1535 innerArrayBegin + 1, pos))
1536 .WillOnce(Return(&mpc));
1537 EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[1].second)), pos, pos + 9, pos + 9))
1538 .WillOnce(Return(&mpc));
1539 EXPECT_CALL(mpc, itemEnd(IsMapOfSize(val.size()), encBegin, encBegin + 1, encEnd))
1540 .WillOnce(Return(&mpc));
1541 }
1542
1543 EXPECT_CALL(mpc, error(_, _)) //
1544 .Times(0);
1545
1546 parse(encoded.data(), encoded.data() + encoded.size(), &mpc);
1547 }
1548
TEST(StreamParseTest,ViewTstr)1549 TEST(StreamParseTest, ViewTstr) {
1550 MockParseClient mpc;
1551
1552 ViewTstr val("Hello");
1553 auto encoded = val.encode();
1554 uint8_t* encBegin = encoded.data();
1555 uint8_t* encEnd = encoded.data() + encoded.size();
1556
1557 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encBegin + 1, encEnd)).WillOnce(Return(&mpc));
1558 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1559 EXPECT_CALL(mpc, error(_, _)).Times(0);
1560
1561 parseWithViews(encoded.data(), encoded.data() + encoded.size(), &mpc);
1562 }
1563
TEST(StreamParseTest,ViewBstr)1564 TEST(StreamParseTest, ViewBstr) {
1565 MockParseClient mpc;
1566
1567 ViewBstr val("Hello");
1568 auto encoded = val.encode();
1569 uint8_t* encBegin = encoded.data();
1570 uint8_t* encEnd = encoded.data() + encoded.size();
1571
1572 EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encBegin + 1, encEnd)).WillOnce(Return(&mpc));
1573 EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0);
1574 EXPECT_CALL(mpc, error(_, _)).Times(0);
1575
1576 parseWithViews(encoded.data(), encoded.data() + encoded.size(), &mpc);
1577 }
1578
TEST(FullParserTest,Uint)1579 TEST(FullParserTest, Uint) {
1580 Uint val(10);
1581
1582 auto [item, pos, message] = parse(val.encode());
1583 EXPECT_THAT(item, MatchesItem(val));
1584 }
1585
TEST(FullParserTest,Null)1586 TEST(FullParserTest, Null) {
1587 Null val;
1588
1589 auto [item, pos, message] = parse(val.encode());
1590 EXPECT_THAT(item, MatchesItem(val));
1591 }
1592
TEST(FullParserTest,Nint)1593 TEST(FullParserTest, Nint) {
1594 Nint val(-10);
1595
1596 auto [item, pos, message] = parse(val.encode());
1597 EXPECT_THAT(item, MatchesItem(val));
1598
1599 vector<uint8_t> minNint = {0x3B, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
1600
1601 std::tie(item, pos, message) = parse(minNint);
1602 EXPECT_THAT(item, NotNull());
1603 EXPECT_EQ(item->asNint()->value(), std::numeric_limits<int64_t>::min());
1604 }
1605
TEST(FullParserTest,NintOutOfRange)1606 TEST(FullParserTest, NintOutOfRange) {
1607 vector<uint8_t> outOfRangeNint = {0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
1608
1609 auto [item, pos, message] = parse(outOfRangeNint);
1610 EXPECT_THAT(item, IsNull());
1611 EXPECT_EQ(pos, outOfRangeNint.data());
1612 EXPECT_EQ(message, "NINT values that don't fit in int64_t are not supported.");
1613 }
1614
TEST(FullParserTest,Tstr)1615 TEST(FullParserTest, Tstr) {
1616 Tstr val("Hello");
1617
1618 auto [item, pos, message] = parse(val.encode());
1619 EXPECT_THAT(item, MatchesItem(val));
1620 }
1621
TEST(FullParserTest,Bstr)1622 TEST(FullParserTest, Bstr) {
1623 Bstr val("\x00\x01\0x02"s);
1624
1625 auto [item, pos, message] = parse(val.encode());
1626 EXPECT_THAT(item, MatchesItem(val));
1627 }
1628
TEST(FullParserTest,Array)1629 TEST(FullParserTest, Array) {
1630 Array val("hello", -4, 3);
1631
1632 auto encoded = val.encode();
1633 auto [item, pos, message] = parse(encoded);
1634 EXPECT_THAT(item, MatchesItem(ByRef(val)));
1635 EXPECT_EQ(pos, encoded.data() + encoded.size());
1636 EXPECT_EQ("", message);
1637
1638 // We've already checked it all, but walk it just for fun.
1639 ASSERT_NE(nullptr, item->asArray());
1640 const Array& arr = *(item->asArray());
1641 ASSERT_EQ(arr[0]->type(), TSTR);
1642 EXPECT_EQ(arr[0]->asTstr()->value(), "hello");
1643 }
1644
TEST(FullParserTest,Map)1645 TEST(FullParserTest, Map) {
1646 Map val("hello", -4, 3, Bstr("hi"));
1647
1648 auto [item, pos, message] = parse(val.encode());
1649 EXPECT_THAT(item, MatchesItem(ByRef(val)));
1650 }
1651
TEST(FullParserTest,SemanticTag)1652 TEST(FullParserTest, SemanticTag) {
1653 SemanticTag val(99, "Salem");
1654
1655 auto [item, pos, message] = parse(val.encode());
1656 EXPECT_THAT(item, MatchesItem(ByRef(val)));
1657 }
1658
TEST(FullParserTest,NestedSemanticTag)1659 TEST(FullParserTest, NestedSemanticTag) {
1660 SemanticTag val(10, SemanticTag(99, "Salem"));
1661
1662 auto [item, pos, message] = parse(val.encode());
1663 EXPECT_THAT(item, MatchesItem(ByRef(val)));
1664 }
1665
TEST(FullParserTest,Complex)1666 TEST(FullParserTest, Complex) {
1667 vector<uint8_t> vec = {0x01, 0x02, 0x08, 0x03};
1668 Map val("Outer1",
1669 Array(Map("Inner1", 99, //
1670 "Inner2", vec),
1671 "foo"),
1672 "Outer2", 10);
1673
1674 std::unique_ptr<Item> item;
1675 const uint8_t* pos;
1676 std::string message;
1677 std::tie(item, pos, message) = parse(val.encode());
1678 EXPECT_THAT(item, MatchesItem(ByRef(val)));
1679 }
1680
TEST(FullParserTest,IncompleteUint)1681 TEST(FullParserTest, IncompleteUint) {
1682 Uint val(1000);
1683
1684 auto encoding = val.encode();
1685 auto [item, pos, message] = parse(encoding.data(), encoding.size() - 1);
1686 EXPECT_EQ(nullptr, item.get());
1687 EXPECT_EQ(encoding.data(), pos);
1688 EXPECT_EQ("Need 2 byte(s) for length field, have 1.", message);
1689 }
1690
TEST(FullParserTest,IncompleteString)1691 TEST(FullParserTest, IncompleteString) {
1692 Tstr val("hello");
1693
1694 auto encoding = val.encode();
1695 auto [item, pos, message] = parse(encoding.data(), encoding.size() - 2);
1696 EXPECT_EQ(nullptr, item.get());
1697 EXPECT_EQ(encoding.data(), pos);
1698 EXPECT_EQ("Need 5 byte(s) for text string, have 3.", message);
1699 }
1700
TEST(FullParserTest,ArrayWithInsufficientEntries)1701 TEST(FullParserTest, ArrayWithInsufficientEntries) {
1702 Array val(1, 2, 3, 4);
1703
1704 auto encoding = val.encode();
1705 auto [item, pos, message] = parse(encoding.data(), encoding.size() - 1);
1706 EXPECT_EQ(nullptr, item.get());
1707 EXPECT_EQ(encoding.data(), pos);
1708 EXPECT_EQ("Not enough entries for array.", message);
1709 }
1710
TEST(FullParserTest,ArrayWithTruncatedEntry)1711 TEST(FullParserTest, ArrayWithTruncatedEntry) {
1712 Array val(1, 2, 3, 400000);
1713
1714 auto encoding = val.encode();
1715 auto [item, pos, message] = parse(encoding.data(), encoding.size() - 1);
1716 EXPECT_EQ(nullptr, item.get());
1717 EXPECT_EQ(encoding.data() + encoding.size() - 5, pos);
1718 EXPECT_EQ("Need 4 byte(s) for length field, have 3.", message);
1719 }
1720
TEST(FullParserTest,MapWithTruncatedEntry)1721 TEST(FullParserTest, MapWithTruncatedEntry) {
1722 Map val(1, 2, 300000, 4);
1723
1724 auto encoding = val.encode();
1725 auto [item, pos, message] = parse(encoding.data(), encoding.size() - 2);
1726 EXPECT_EQ(nullptr, item.get());
1727 EXPECT_EQ(encoding.data() + 3, pos);
1728 EXPECT_EQ("Need 4 byte(s) for length field, have 3.", message);
1729 }
1730
TEST(FullParserTest,ViewTstr)1731 TEST(FullParserTest, ViewTstr) {
1732 ViewTstr val("Hello");
1733
1734 auto enc = val.encode();
1735 auto [item, pos, message] = parseWithViews(enc.data(), enc.size());
1736 EXPECT_THAT(item, MatchesItem(val));
1737 }
1738
TEST(FullParserTest,ViewBstr)1739 TEST(FullParserTest, ViewBstr) {
1740 const std::string strVal = "\x00\x01\x02"s;
1741 const ViewBstr val(strVal);
1742 EXPECT_EQ(val.toString(), "\x43\x00\x01\x02"s);
1743
1744 auto enc = val.encode();
1745 auto [item, pos, message] = parseWithViews(enc.data(), enc.size());
1746 EXPECT_THAT(item, MatchesItem(val));
1747 EXPECT_EQ(hexDump(item->toString()), hexDump(val.toString()));
1748 }
1749
TEST(FullParserTest,ReservedAdditionalInformation)1750 TEST(FullParserTest, ReservedAdditionalInformation) {
1751 vector<uint8_t> reservedVal = {0x1D};
1752
1753 auto [item, pos, message] = parse(reservedVal);
1754 EXPECT_THAT(item, IsNull());
1755 EXPECT_EQ(pos, reservedVal.data());
1756 EXPECT_EQ("Reserved additional information value or unsupported indefinite length item.",
1757 message);
1758 }
1759
TEST(FullParserTest,IndefiniteArray)1760 TEST(FullParserTest, IndefiniteArray) {
1761 vector<uint8_t> indefiniteArray = {0x7F};
1762
1763 auto [item, pos, message] = parse(indefiniteArray);
1764 EXPECT_THAT(item, IsNull());
1765 EXPECT_EQ(pos, indefiniteArray.data());
1766 EXPECT_EQ("Reserved additional information value or unsupported indefinite length item.",
1767 message);
1768 }
1769
TEST(FullParserTest,UnassignedSimpleValue)1770 TEST(FullParserTest, UnassignedSimpleValue) {
1771 vector<uint8_t> unassignedSimpleValue = {0xE5};
1772
1773 auto [item, pos, message] = parse(unassignedSimpleValue);
1774 EXPECT_THAT(item, IsNull());
1775 EXPECT_EQ(pos, unassignedSimpleValue.data());
1776 EXPECT_EQ("Unsupported floating-point or simple value.", message);
1777 }
1778
TEST(FullParserTest,FloatingPointValue)1779 TEST(FullParserTest, FloatingPointValue) {
1780 vector<uint8_t> floatingPointValue = {0xFA, 0x12, 0x75, 0x34, 0x37};
1781
1782 auto [item, pos, message] = parse(floatingPointValue);
1783 EXPECT_THAT(item, IsNull());
1784 EXPECT_EQ(pos, floatingPointValue.data());
1785 EXPECT_EQ("Unsupported floating-point or simple value.", message);
1786 }
1787
TEST(MapGetValueByKeyTest,Map)1788 TEST(MapGetValueByKeyTest, Map) {
1789 Array compoundItem(1, 2, 3, 4, 5, Map(4, 5, "a", "b"));
1790 auto clone = compoundItem.clone();
1791 Map item(1, 2, "key", "value", "item", std::move(compoundItem));
1792 auto& value1 = item.get(1);
1793 EXPECT_NE(value1.get(), nullptr);
1794 EXPECT_EQ(*value1, Uint(2));
1795 auto& value2 = item.get("key");
1796 EXPECT_NE(value2.get(), nullptr);
1797 EXPECT_EQ(*value2, Tstr("value"));
1798 auto& value3 = item.get("item");
1799 EXPECT_NE(value3.get(), nullptr);
1800 EXPECT_EQ(*value3, *clone);
1801 auto& value4 = item.get("wrong");
1802 EXPECT_EQ(value4.get(), nullptr);
1803 }
1804
TEST(EmptyBstrTest,Bstr)1805 TEST(EmptyBstrTest, Bstr) {
1806 Bstr bstr(std::vector<uint8_t>{});
1807 auto encoding = bstr.encode();
1808 auto [obj, pos, message] = parse(encoding.data(), encoding.size());
1809 EXPECT_NE(obj.get(), nullptr);
1810 EXPECT_EQ(*obj, bstr);
1811 }
1812
TEST(ArrayIterationTest,EmptyArray)1813 TEST(ArrayIterationTest, EmptyArray) {
1814 Array array;
1815 EXPECT_EQ(array.begin(), array.end());
1816
1817 const Array& const_array = array;
1818 EXPECT_EQ(const_array.begin(), const_array.end());
1819 }
1820
TEST(ArrayIterationTest,ForwardTest)1821 TEST(ArrayIterationTest, ForwardTest) {
1822 Array array(1, 2, 3, "hello", -4);
1823
1824 auto iter = array.begin();
1825 ASSERT_NE(iter, array.end());
1826 EXPECT_EQ(**iter, Uint(1));
1827
1828 ASSERT_NE(++iter, array.end());
1829 EXPECT_EQ(**iter++, Uint(2));
1830
1831 ASSERT_NE(iter, array.end());
1832 EXPECT_EQ(**iter, Uint(3));
1833
1834 ASSERT_NE(++iter, array.end());
1835 EXPECT_EQ(**iter++, Tstr("hello"));
1836
1837 ASSERT_NE(iter, array.end());
1838 EXPECT_EQ(**iter, Nint(-4));
1839
1840 EXPECT_EQ(++iter, array.end());
1841 }
1842
TEST(ArrayIterationTest,BidirectionalTest)1843 TEST(ArrayIterationTest, BidirectionalTest) {
1844 Array array(1, 2, 3, "hello", -4);
1845
1846 auto iter = array.begin();
1847 ASSERT_NE(iter, array.end());
1848 EXPECT_EQ(**iter, Uint(1));
1849
1850 ASSERT_NE(++iter, array.end());
1851 EXPECT_EQ(**iter, Uint(2));
1852
1853 ASSERT_NE(--iter, array.end());
1854 ASSERT_EQ(iter, array.begin());
1855 EXPECT_EQ(**iter, Uint(1));
1856
1857 ASSERT_NE(++iter, array.end());
1858 EXPECT_EQ(**iter, Uint(2));
1859
1860 ASSERT_NE(++iter, array.end());
1861 EXPECT_EQ(**iter--, Uint(3));
1862
1863 ASSERT_NE(++iter, array.end());
1864 EXPECT_EQ(**iter, Uint(3));
1865
1866 ASSERT_NE(++iter, array.end());
1867 EXPECT_EQ(**iter, Tstr("hello"));
1868
1869 ASSERT_NE(++iter, array.end());
1870 EXPECT_EQ(**iter, Nint(-4));
1871
1872 EXPECT_EQ(++iter, array.end());
1873 }
1874
TEST(MapIterationTest,EmptyMap)1875 TEST(MapIterationTest, EmptyMap) {
1876 Map map;
1877
1878 EXPECT_EQ(map.begin(), map.end());
1879 }
1880
TEST(MapIterationTest,ForwardTest)1881 TEST(MapIterationTest, ForwardTest) {
1882 Map map(1, 2, 3, "hello", -4, 5);
1883
1884 auto iter = map.begin();
1885 ASSERT_NE(iter, map.end());
1886 EXPECT_EQ(*iter->first, Uint(1));
1887 EXPECT_EQ(*iter->second, Uint(2));
1888
1889 ASSERT_NE(++iter, map.end());
1890 EXPECT_EQ(*iter->first, Uint(3));
1891 EXPECT_EQ(*(iter++)->second, Tstr("hello"));
1892
1893 ASSERT_NE(iter, map.end());
1894 EXPECT_EQ(*iter->first, Nint(-4));
1895 EXPECT_EQ(*(iter++)->second, Uint(5));
1896
1897 EXPECT_EQ(iter, map.end());
1898 }
1899
TEST(MapIterationTest,BidirectionalTest)1900 TEST(MapIterationTest, BidirectionalTest) {
1901 Map map(1, 2, 3, "hello", -4, 5);
1902
1903 auto iter = map.begin();
1904 ASSERT_NE(iter, map.end());
1905 EXPECT_EQ(*iter->first, Uint(1));
1906 EXPECT_EQ(*iter->second, Uint(2));
1907
1908 ASSERT_NE(++iter, map.end());
1909 EXPECT_EQ(*iter->first, Uint(3));
1910 EXPECT_EQ(*(iter--)->second, Tstr("hello"));
1911
1912 ASSERT_NE(iter, map.end());
1913 EXPECT_EQ(*iter->first, Uint(1));
1914 EXPECT_EQ(*(iter++)->second, Uint(2));
1915
1916 ASSERT_NE(iter, map.end());
1917 EXPECT_EQ(*iter->first, Uint(3));
1918 EXPECT_EQ(*iter->second, Tstr("hello"));
1919
1920 ASSERT_NE(++iter, map.end());
1921 EXPECT_EQ(*iter->first, Nint(-4));
1922 EXPECT_EQ(*(iter++)->second, Uint(5));
1923
1924 EXPECT_EQ(iter, map.end());
1925 }
1926
main(int argc,char ** argv)1927 int main(int argc, char** argv) {
1928 ::testing::InitGoogleTest(&argc, argv);
1929 return RUN_ALL_TESTS();
1930 }
1931