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