1 // Copyright 2021 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include "dice/cbor_reader.h"
16
17 #include "dice/test_framework.h"
18
19 namespace {
20
21 extern "C" {
22
TEST(CborReaderTest,Int1Byte)23 TEST(CborReaderTest, Int1Byte) {
24 const uint8_t buffer[] = {0, 23, 0x20, 0x37};
25 int64_t val;
26 CborIn in;
27 CborInInit(buffer, sizeof(buffer), &in);
28 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
29 EXPECT_EQ(0, val);
30 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
31 EXPECT_EQ(23, val);
32 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
33 EXPECT_EQ(-1, val);
34 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
35 EXPECT_EQ(-24, val);
36 EXPECT_TRUE(CborInAtEnd(&in));
37 }
38
TEST(CborReaderTest,Int2Bytes)39 TEST(CborReaderTest, Int2Bytes) {
40 const uint8_t buffer[] = {24, 24, 24, 0xff, 0x38, 24, 0x38, 0xff};
41 int64_t val;
42 CborIn in;
43 CborInInit(buffer, sizeof(buffer), &in);
44 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
45 EXPECT_EQ(24, val);
46 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
47 EXPECT_EQ(0xff, val);
48 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
49 EXPECT_EQ(-25, val);
50 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
51 EXPECT_EQ(-0x100, val);
52 EXPECT_TRUE(CborInAtEnd(&in));
53 }
54
TEST(CborReaderTest,Int3Bytes)55 TEST(CborReaderTest, Int3Bytes) {
56 const uint8_t buffer[] = {25, 0x01, 0x00, 25, 0xff, 0xff,
57 0x39, 0x01, 0x00, 0x39, 0xff, 0xff};
58 int64_t val;
59 CborIn in;
60 CborInInit(buffer, sizeof(buffer), &in);
61 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
62 EXPECT_EQ(0x100, val);
63 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
64 EXPECT_EQ(0xffff, val);
65 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
66 EXPECT_EQ(-0x101, val);
67 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
68 EXPECT_EQ(-0x10000, val);
69 EXPECT_TRUE(CborInAtEnd(&in));
70 }
71
TEST(CborReaderTest,Int5Bytes)72 TEST(CborReaderTest, Int5Bytes) {
73 const uint8_t buffer[] = {26, 0x00, 0x01, 0x00, 0x00, 26, 0xff,
74 0xff, 0xff, 0xff, 0x3a, 0x00, 0x01, 0x00,
75 0x00, 0x3a, 0xff, 0xff, 0xff, 0xff};
76 int64_t val;
77 CborIn in;
78 CborInInit(buffer, sizeof(buffer), &in);
79 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
80 EXPECT_EQ(0x10000, val);
81 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
82 EXPECT_EQ(0xffffffff, val);
83 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
84 EXPECT_EQ(-0x10001, val);
85 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
86 EXPECT_EQ(-0x100000000, val);
87 EXPECT_TRUE(CborInAtEnd(&in));
88 }
89
TEST(CborReaderTest,Int9Bytes)90 TEST(CborReaderTest, Int9Bytes) {
91 const uint8_t buffer[] = {
92 27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 27, 0x7f, 0xff,
93 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0x00, 0x00, 0x00, 0x01, 0x00,
94 0x00, 0x00, 0x00, 0x3b, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
95 int64_t val;
96 CborIn in;
97 CborInInit(buffer, sizeof(buffer), &in);
98 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
99 EXPECT_EQ(0x100000000, val);
100 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
101 EXPECT_EQ(INT64_MAX, val);
102 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
103 EXPECT_EQ(-0x100000001, val);
104 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
105 EXPECT_EQ(INT64_MIN, val);
106 EXPECT_TRUE(CborInAtEnd(&in));
107 }
108
TEST(CborReaderTest,Uint9Bytes)109 TEST(CborReaderTest, Uint9Bytes) {
110 const uint8_t buffer[] = {27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
111 27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
112 uint64_t val;
113 CborIn in;
114 CborInInit(buffer, sizeof(buffer), &in);
115 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadUint(&in, &val));
116 EXPECT_EQ(0x100000000u, val);
117 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadUint(&in, &val));
118 EXPECT_EQ(UINT64_MAX, val);
119 EXPECT_TRUE(CborInAtEnd(&in));
120 }
121
TEST(CborReaderTest,IntByteOrder)122 TEST(CborReaderTest, IntByteOrder) {
123 const uint8_t buffer[] = {
124 25, 0x12, 0x34, 26, 0x12, 0x34, 0x56, 0x78, 27,
125 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
126 };
127 int64_t val;
128 CborIn in;
129 CborInInit(buffer, sizeof(buffer), &in);
130 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
131 EXPECT_EQ(0x1234, val);
132 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
133 EXPECT_EQ(0x12345678, val);
134 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadInt(&in, &val));
135 EXPECT_EQ(0x123456789abcdef0, val);
136 EXPECT_TRUE(CborInAtEnd(&in));
137 }
138
TEST(CborReaderTest,IntMalformed)139 TEST(CborReaderTest, IntMalformed) {
140 const uint8_t kTooBigBuffer[] = {27, 0x80, 0, 0, 0, 0, 0, 0, 0};
141 const uint8_t kTooSmallBuffer[] = {0x3b, 0x80, 0, 0, 0, 0, 0, 0, 0};
142 const uint8_t kBadAddlBuffer[] = {30};
143 const uint8_t kNegBadAddlBuffer[] = {0x3c};
144 int64_t val;
145 CborIn in;
146 CborInInit(kTooBigBuffer, sizeof(kTooBigBuffer), &in);
147 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
148 CborInInit(kTooSmallBuffer, sizeof(kTooSmallBuffer), &in);
149 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
150 CborInInit(kBadAddlBuffer, sizeof(kBadAddlBuffer), &in);
151 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
152 CborInInit(kNegBadAddlBuffer, sizeof(kNegBadAddlBuffer), &in);
153 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadInt(&in, &val));
154 EXPECT_FALSE(CborInAtEnd(&in));
155 }
156
TEST(CborReaderTest,IntTooShort)157 TEST(CborReaderTest, IntTooShort) {
158 const uint8_t buffer[] = {27, 0x40, 0, 0, 0, 0, 0, 0};
159 int64_t val;
160 CborIn in;
161 CborInInit(buffer, sizeof(buffer), &in);
162 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadInt(&in, &val));
163 EXPECT_FALSE(CborInAtEnd(&in));
164 }
165
TEST(CborReaderTest,BstrEncoding)166 TEST(CborReaderTest, BstrEncoding) {
167 const uint8_t buffer[] = {0x45, 'h', 'e', 'l', 'l', 'o'};
168 const uint8_t kData[] = {'h', 'e', 'l', 'l', 'o'};
169 size_t data_size;
170 const uint8_t* data;
171 CborIn in;
172 CborInInit(buffer, sizeof(buffer), &in);
173 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadBstr(&in, &data_size, &data));
174 EXPECT_EQ(sizeof(kData), data_size);
175 EXPECT_EQ(0, memcmp(data, kData, data_size));
176 EXPECT_TRUE(CborInAtEnd(&in));
177 }
178
TEST(CborReaderTest,BstrLongEncoding)179 TEST(CborReaderTest, BstrLongEncoding) {
180 const uint8_t buffer[] = {
181 0x58, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00,
182 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00,
183 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x99,
184 };
185 size_t data_size;
186 const uint8_t* data;
187 CborIn in;
188 CborInInit(buffer, sizeof(buffer), &in);
189 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadBstr(&in, &data_size, &data));
190 EXPECT_EQ(32u, data_size);
191 EXPECT_EQ(0, memcmp(data, buffer + 2, 32));
192 EXPECT_TRUE(CborInAtEnd(&in));
193 }
194
TEST(CborReaderTest,TstrEncoding)195 TEST(CborReaderTest, TstrEncoding) {
196 const uint8_t buffer[] = {0x65, 'w', 'o', 'r', 'l', 'd'};
197 const char kStr[] = "world";
198 size_t size;
199 const char* str;
200 CborIn in;
201 CborInInit(buffer, sizeof(buffer), &in);
202 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTstr(&in, &size, &str));
203 EXPECT_EQ(strlen(kStr), size);
204 EXPECT_EQ(0, memcmp(str, kStr, size));
205 EXPECT_TRUE(CborInAtEnd(&in));
206 }
207
TEST(CborReaderTest,ArrayEncoding)208 TEST(CborReaderTest, ArrayEncoding) {
209 const uint8_t buffer[] = {0x98, 29};
210 size_t num_elements;
211 CborIn in;
212 CborInInit(buffer, sizeof(buffer), &in);
213 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadArray(&in, &num_elements));
214 EXPECT_EQ(29u, num_elements);
215 EXPECT_TRUE(CborInAtEnd(&in));
216 }
217
TEST(CborReaderTest,MapEncoding)218 TEST(CborReaderTest, MapEncoding) {
219 const uint8_t buffer[] = {0xb9, 0x02, 0x50};
220 size_t num_pairs;
221 CborIn in;
222 CborInInit(buffer, sizeof(buffer), &in);
223 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadMap(&in, &num_pairs));
224 EXPECT_EQ(592u, num_pairs);
225 EXPECT_TRUE(CborInAtEnd(&in));
226 }
227
TEST(CborReaderTest,FalseEncoding)228 TEST(CborReaderTest, FalseEncoding) {
229 const uint8_t buffer[] = {0xf4};
230 CborIn in;
231 CborInInit(buffer, sizeof(buffer), &in);
232 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadFalse(&in));
233 EXPECT_TRUE(CborInAtEnd(&in));
234 }
235
TEST(CborReaderTest,TrueEncoding)236 TEST(CborReaderTest, TrueEncoding) {
237 const uint8_t buffer[] = {0xf5};
238 CborIn in;
239 CborInInit(buffer, sizeof(buffer), &in);
240 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTrue(&in));
241 EXPECT_TRUE(CborInAtEnd(&in));
242 }
243
TEST(CborReaderTest,NullEncoding)244 TEST(CborReaderTest, NullEncoding) {
245 const uint8_t buffer[] = {0xf6};
246 CborIn in;
247 CborInInit(buffer, sizeof(buffer), &in);
248 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadNull(&in));
249 EXPECT_TRUE(CborInAtEnd(&in));
250 }
251
TEST(CborReaderTest,TagEncoding)252 TEST(CborReaderTest, TagEncoding) {
253 const uint8_t buffer[] = {0xcf, 0xd8, 0x18, 0xd9, 0xd9, 0xf8, 0xda,
254 0x4f, 0x50, 0x53, 0x4e, 0xdb, 0x10, 0x00,
255 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
256 CborIn in;
257 uint64_t tag;
258 CborInInit(buffer, sizeof(buffer), &in);
259 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
260 EXPECT_EQ(/* Unassigned */ 15u, tag);
261 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
262 EXPECT_EQ(/* COSE_Sign1 */ 24u, tag);
263 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
264 EXPECT_EQ(/* Byte string */ 0xd9f8u, tag);
265 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
266 EXPECT_EQ(/* Openswan cfg */ 0x4f50534eu, tag);
267 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
268 EXPECT_EQ(/* Unassigned */ 0x1000000000000000u, tag);
269 EXPECT_TRUE(CborInAtEnd(&in));
270 }
271
TEST(CborReaderTest,TagInvalid)272 TEST(CborReaderTest, TagInvalid) {
273 // The following tags are always invalid but are treated as any other tag.
274 // Reference https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml.
275 const uint8_t invalid16[] = {0xd9, 0xff, 0xff};
276 const uint8_t invalid32[] = {0xda, 0xff, 0xff, 0xff, 0xff};
277 const uint8_t invalid64[] = {0xdb, 0xff, 0xff, 0xff, 0xff,
278 0xff, 0xff, 0xff, 0xff};
279 CborIn in;
280 uint64_t tag;
281 CborInInit(invalid16, sizeof(invalid16), &in);
282 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
283 EXPECT_TRUE(CborInAtEnd(&in));
284 CborInInit(invalid32, sizeof(invalid32), &in);
285 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
286 EXPECT_TRUE(CborInAtEnd(&in));
287 CborInInit(invalid64, sizeof(invalid64), &in);
288 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadTag(&in, &tag));
289 EXPECT_TRUE(CborInAtEnd(&in));
290 }
291
TEST(CborReaderTest,Skip)292 TEST(CborReaderTest, Skip) {
293 const uint8_t buffer[] = {0x84, 0x03, 0xa2, 0x82, 0x23, 0x05, 0xf4,
294 0x16, 0xf6, 0x61, 0x44, 0x41, 0xaa};
295 const uint8_t tag[] = {0xc4, 0xf5};
296 const uint8_t tagtag[] = {0xc4, 0xc4, 0xf5};
297 const uint8_t nested_tag[] = {0x82, 0xa1, 0x02, 0xc7, 0x04, 0x09};
298 CborIn in;
299 CborInInit(buffer, sizeof(buffer), &in);
300 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadSkip(&in));
301 EXPECT_TRUE(CborInAtEnd(&in));
302 CborInInit(tag, sizeof(tag), &in);
303 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadSkip(&in));
304 EXPECT_TRUE(CborInAtEnd(&in));
305 CborInInit(tagtag, sizeof(tagtag), &in);
306 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadSkip(&in));
307 EXPECT_TRUE(CborInAtEnd(&in));
308 CborInInit(nested_tag, sizeof(nested_tag), &in);
309 EXPECT_EQ(CBOR_READ_RESULT_OK, CborReadSkip(&in));
310 EXPECT_TRUE(CborInAtEnd(&in));
311 }
312
TEST(CborReaderTest,SkipTooDeeplyNestedMalformed)313 TEST(CborReaderTest, SkipTooDeeplyNestedMalformed) {
314 const uint8_t map[] = {0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
315 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1};
316 const uint8_t array[] = {0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
317 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
318 0x82, 0x82, 0x82, 0x82, 0x82, 0x82};
319 CborIn in;
320 CborInInit(map, sizeof(map), &in);
321 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
322 EXPECT_EQ(0u, CborInOffset(&in));
323 CborInInit(array, sizeof(array), &in);
324 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
325 EXPECT_EQ(0u, CborInOffset(&in));
326 }
327
TEST(CborReaderTest,EmptyBufferAtEnd)328 TEST(CborReaderTest, EmptyBufferAtEnd) {
329 int64_t val;
330 uint64_t uval;
331 size_t size;
332 const uint8_t* data;
333 const char* str;
334 CborIn in;
335 CborInInit(nullptr, 0, &in);
336 EXPECT_TRUE(CborInAtEnd(&in));
337 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadInt(&in, &val));
338 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadUint(&in, &uval));
339 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadBstr(&in, &size, &data));
340 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadTstr(&in, &size, &str));
341 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadArray(&in, &size));
342 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadMap(&in, &size));
343 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadFalse(&in));
344 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadTrue(&in));
345 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadNull(&in));
346 EXPECT_EQ(CBOR_READ_RESULT_END, CborReadTag(&in, &uval));
347 EXPECT_EQ(0u, CborInOffset(&in));
348 }
349
TEST(CborReaderTest,NotFound)350 TEST(CborReaderTest, NotFound) {
351 const uint8_t buffer[] = {0xe0, 0x08};
352 int64_t val;
353 uint64_t uval;
354 size_t size;
355 const uint8_t* data;
356 const char* str;
357 CborIn in;
358 CborInInit(buffer, sizeof(buffer), &in);
359 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadInt(&in, &val));
360 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadUint(&in, &uval));
361 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadBstr(&in, &size, &data));
362 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadTstr(&in, &size, &str));
363 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadArray(&in, &size));
364 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadMap(&in, &size));
365 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadFalse(&in));
366 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadTrue(&in));
367 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadNull(&in));
368 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadTag(&in, &uval));
369 EXPECT_EQ(0u, CborInOffset(&in));
370 }
371
TEST(CborReaderTest,SimpleValueNotFound)372 TEST(CborReaderTest, SimpleValueNotFound) {
373 const uint8_t buffer[] = {0xf7};
374 CborIn in;
375 CborInInit(buffer, sizeof(buffer), &in);
376 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadFalse(&in));
377 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadTrue(&in));
378 EXPECT_EQ(CBOR_READ_RESULT_NOT_FOUND, CborReadNull(&in));
379 EXPECT_EQ(0u, CborInOffset(&in));
380 }
381
TEST(CborReaderTest,IndefiniteLengthMalformed)382 TEST(CborReaderTest, IndefiniteLengthMalformed) {
383 size_t size;
384 const uint8_t* data;
385 const char* str;
386 CborIn in;
387 const uint8_t bstr[] = {0x5f, 0x44, 0xaa, 0xbb, 0xcc, 0xdd,
388 0x43, 0xee, 0xff, 0x99, 0xff};
389 CborInInit(bstr, sizeof(bstr), &in);
390 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadBstr(&in, &size, &data));
391 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
392 EXPECT_EQ(0u, CborInOffset(&in));
393 const uint8_t tstr[] = {0x7f, 0x64, 0x41, 0x42, 0x43, 0x44,
394 0x63, 0x30, 0x31, 0x32, 0xff};
395 CborInInit(tstr, sizeof(tstr), &in);
396 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadTstr(&in, &size, &str));
397 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
398 EXPECT_EQ(0u, CborInOffset(&in));
399 const uint8_t array[] = {0x9f, 0x01, 0x82, 0x02, 0x03,
400 0x82, 0x04, 0x05, 0xff};
401 CborInInit(array, sizeof(array), &in);
402 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadArray(&in, &size));
403 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
404 EXPECT_EQ(0u, CborInOffset(&in));
405 const uint8_t map[] = {0xbf, 0x63, 0x46, 0x75, 0x6e, 0xf5,
406 0x63, 0x41, 0x6d, 0x74, 0x21, 0xff};
407 CborInInit(map, sizeof(map), &in);
408 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadMap(&in, &size));
409 EXPECT_EQ(CBOR_READ_RESULT_MALFORMED, CborReadSkip(&in));
410 EXPECT_EQ(0u, CborInOffset(&in));
411 }
412 }
413
414 } // namespace
415