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