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_writer.h"
16
17 #include "dice/test_framework.h"
18
19 namespace {
20
21 extern "C" {
22
TEST(CborWriterTest,Int1ByteEncoding)23 TEST(CborWriterTest, Int1ByteEncoding) {
24 const uint8_t kExpectedEncoding[] = {0, 23, 0x20, 0x37};
25 uint8_t buffer[64];
26 CborOut out;
27 CborOutInit(buffer, sizeof(buffer), &out);
28 CborWriteInt(0, &out);
29 CborWriteInt(23, &out);
30 CborWriteInt(-1, &out);
31 CborWriteInt(-24, &out);
32 EXPECT_FALSE(CborOutOverflowed(&out));
33 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
34 }
35
TEST(CborWriterTest,Int2Bytes)36 TEST(CborWriterTest, Int2Bytes) {
37 const uint8_t kExpectedEncoding[] = {24, 24, 24, 0xff, 0x38, 24, 0x38, 0xff};
38 uint8_t buffer[64];
39 CborOut out;
40 CborOutInit(buffer, sizeof(buffer), &out);
41 CborWriteInt(24, &out);
42 CborWriteInt(0xff, &out);
43 CborWriteInt(-25, &out);
44 CborWriteInt(-0x100, &out);
45 EXPECT_FALSE(CborOutOverflowed(&out));
46 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
47 }
48
TEST(CborWriterTest,Int3Bytes)49 TEST(CborWriterTest, Int3Bytes) {
50 const uint8_t kExpectedEncoding[] = {25, 0x01, 0x00, 25, 0xff, 0xff,
51 0x39, 0x01, 0x00, 0x39, 0xff, 0xff};
52 uint8_t buffer[64];
53 CborOut out;
54 CborOutInit(buffer, sizeof(buffer), &out);
55 CborWriteInt(0x100, &out);
56 CborWriteInt(0xffff, &out);
57 CborWriteInt(-0x101, &out);
58 CborWriteInt(-0x10000, &out);
59 EXPECT_FALSE(CborOutOverflowed(&out));
60 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
61 }
62
TEST(CborWriterTest,Int5Bytes)63 TEST(CborWriterTest, Int5Bytes) {
64 const uint8_t kExpectedEncoding[] = {26, 0x00, 0x01, 0x00, 0x00, 26, 0xff,
65 0xff, 0xff, 0xff, 0x3a, 0x00, 0x01, 0x00,
66 0x00, 0x3a, 0xff, 0xff, 0xff, 0xff};
67 uint8_t buffer[64];
68 CborOut out;
69 CborOutInit(buffer, sizeof(buffer), &out);
70 CborWriteInt(0x10000, &out);
71 CborWriteInt(0xffffffff, &out);
72 CborWriteInt(-0x10001, &out);
73 CborWriteInt(-0x100000000, &out);
74 EXPECT_FALSE(CborOutOverflowed(&out));
75 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
76 }
77
TEST(CborWriterTest,Int9Bytes)78 TEST(CborWriterTest, Int9Bytes) {
79 const uint8_t kExpectedEncoding[] = {
80 27, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 27, 0x7f, 0xff,
81 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0x00, 0x00, 0x00, 0x01, 0x00,
82 0x00, 0x00, 0x00, 0x3b, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
83 uint8_t buffer[64];
84 CborOut out;
85 CborOutInit(buffer, sizeof(buffer), &out);
86 CborWriteInt(0x100000000, &out);
87 CborWriteInt(INT64_MAX, &out);
88 CborWriteInt(-0x100000001, &out);
89 CborWriteInt(INT64_MIN, &out);
90 EXPECT_FALSE(CborOutOverflowed(&out));
91 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
92 }
93
TEST(CborWriterTest,Uint9Bytes)94 TEST(CborWriterTest, Uint9Bytes) {
95 const uint8_t kExpectedEncoding[] = {27, 0x00, 0x00, 0x00, 0x01, 0x00,
96 0x00, 0x00, 0x00, 27, 0xff, 0xff,
97 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
98 uint8_t buffer[64];
99 CborOut out;
100 CborOutInit(buffer, sizeof(buffer), &out);
101 CborWriteUint(0x100000000, &out);
102 CborWriteUint(UINT64_MAX, &out);
103 EXPECT_FALSE(CborOutOverflowed(&out));
104 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
105 }
106
TEST(CborWriterTest,IntByteOrder)107 TEST(CborWriterTest, IntByteOrder) {
108 const uint8_t kExpectedEncoding[] = {
109 25, 0x12, 0x34, 26, 0x12, 0x34, 0x56, 0x78, 27,
110 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
111 };
112 uint8_t buffer[64];
113 CborOut out;
114 CborOutInit(buffer, sizeof(buffer), &out);
115 CborWriteInt(0x1234, &out);
116 CborWriteInt(0x12345678, &out);
117 CborWriteInt(0x123456789abcdef0, &out);
118 EXPECT_FALSE(CborOutOverflowed(&out));
119 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
120 }
121
TEST(CborWriterTest,BstrEncoding)122 TEST(CborWriterTest, BstrEncoding) {
123 const uint8_t kExpectedEncoding[] = {0x45, 'h', 'e', 'l', 'l', 'o'};
124 const uint8_t kData[] = {'h', 'e', 'l', 'l', 'o'};
125 uint8_t buffer[64];
126 CborOut out;
127 CborOutInit(buffer, sizeof(buffer), &out);
128 CborWriteBstr(sizeof(kData), kData, &out);
129 EXPECT_FALSE(CborOutOverflowed(&out));
130 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
131 }
132
TEST(CborWriterTest,BstrAllocEncoding)133 TEST(CborWriterTest, BstrAllocEncoding) {
134 const uint8_t kExpectedEncoding[] = {0x45, 'a', 'l', 'l', 'o', 'c'};
135 const uint8_t kData[] = {'a', 'l', 'l', 'o', 'c'};
136 uint8_t buffer[64];
137 uint8_t* ptr;
138 CborOut out;
139 CborOutInit(buffer, sizeof(buffer), &out);
140 ptr = CborAllocBstr(sizeof(kData), &out);
141 EXPECT_NE(nullptr, ptr);
142 EXPECT_FALSE(CborOutOverflowed(&out));
143 memcpy(ptr, kData, sizeof(kData));
144 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
145 }
146
TEST(CborWriterTest,TstrEncoding)147 TEST(CborWriterTest, TstrEncoding) {
148 const uint8_t kExpectedEncoding[] = {0x65, 'w', 'o', 'r', 'l', 'd'};
149 uint8_t buffer[64];
150 CborOut out;
151 CborOutInit(buffer, sizeof(buffer), &out);
152 CborWriteTstr("world", &out);
153 EXPECT_FALSE(CborOutOverflowed(&out));
154 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
155 }
156
TEST(CborWriterTest,TstrAllocEncoding)157 TEST(CborWriterTest, TstrAllocEncoding) {
158 const uint8_t kExpectedEncoding[] = {0x65, 's', 'p', 'a', 'c', 'e'};
159 const char kStr[] = "space";
160 char* ptr;
161 uint8_t buffer[64];
162 CborOut out;
163 CborOutInit(buffer, sizeof(buffer), &out);
164 ptr = CborAllocTstr(strlen(kStr), &out);
165 EXPECT_NE(nullptr, ptr);
166 EXPECT_FALSE(CborOutOverflowed(&out));
167 memcpy(ptr, kStr, sizeof(kStr));
168 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
169 }
170
TEST(CborWriterTest,ArrayEncoding)171 TEST(CborWriterTest, ArrayEncoding) {
172 const uint8_t kExpectedEncoding[] = {0x98, 29};
173 uint8_t buffer[64];
174 CborOut out;
175 CborOutInit(buffer, sizeof(buffer), &out);
176 CborWriteArray(/*num_elements=*/29, &out);
177 EXPECT_FALSE(CborOutOverflowed(&out));
178 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
179 }
180
TEST(CborWriterTest,MapEncoding)181 TEST(CborWriterTest, MapEncoding) {
182 const uint8_t kExpectedEncoding[] = {0xb9, 0x02, 0x50};
183 uint8_t buffer[64];
184 CborOut out;
185 CborOutInit(buffer, sizeof(buffer), &out);
186 CborWriteMap(/*num_pairs=*/592, &out);
187 EXPECT_FALSE(CborOutOverflowed(&out));
188 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
189 }
190
TEST(CborWriterTest,FalseEncoding)191 TEST(CborWriterTest, FalseEncoding) {
192 const uint8_t kExpectedEncoding[] = {0xf4};
193 uint8_t buffer[64];
194 CborOut out;
195 CborOutInit(buffer, sizeof(buffer), &out);
196 CborWriteFalse(&out);
197 EXPECT_FALSE(CborOutOverflowed(&out));
198 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
199 }
200
TEST(CborWriterTest,TrueEncoding)201 TEST(CborWriterTest, TrueEncoding) {
202 const uint8_t kExpectedEncoding[] = {0xf5};
203 uint8_t buffer[64];
204 CborOut out;
205 CborOutInit(buffer, sizeof(buffer), &out);
206 CborWriteTrue(&out);
207 EXPECT_FALSE(CborOutOverflowed(&out));
208 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
209 }
210
TEST(CborWriterTest,NullEncoding)211 TEST(CborWriterTest, NullEncoding) {
212 const uint8_t kExpectedEncoding[] = {0xf6};
213 uint8_t buffer[64];
214 CborOut out;
215 CborOutInit(buffer, sizeof(buffer), &out);
216 CborWriteNull(&out);
217 EXPECT_FALSE(CborOutOverflowed(&out));
218 EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
219 }
220
TEST(CborWriterTest,CborOutInvariants)221 TEST(CborWriterTest, CborOutInvariants) {
222 const uint8_t kData[] = {0xb2, 0x34, 0x75, 0x92, 0x52};
223 uint8_t buffer[64];
224 CborOut out;
225 CborOutInit(buffer, sizeof(buffer), &out);
226 CborWriteInt(0xab34, &out);
227 CborWriteBstr(sizeof(kData), kData, &out);
228 EXPECT_NE(nullptr, CborAllocBstr(7, &out));
229 CborWriteTstr("A string", &out);
230 EXPECT_NE(nullptr, CborAllocTstr(6, &out));
231 CborWriteArray(/*num_elements=*/16, &out);
232 CborWriteMap(/*num_pairs=*/35, &out);
233 CborWriteFalse(&out);
234 CborWriteTrue(&out);
235 CborWriteNull(&out);
236 EXPECT_FALSE(CborOutOverflowed(&out));
237 // Offset is the cumulative size.
238 EXPECT_EQ(3 + 6 + 8 + 9 + 7 + 1 + 2 + 1 + 1 + 1u, CborOutSize(&out));
239 }
240
TEST(CborWriterTest,NullBufferForMeasurement)241 TEST(CborWriterTest, NullBufferForMeasurement) {
242 const uint8_t kData[] = {16, 102, 246, 12, 156, 35, 84};
243 CborOut out;
244 CborOutInit(nullptr, 0, &out);
245 CborWriteNull(&out);
246 CborWriteTrue(&out);
247 CborWriteFalse(&out);
248 CborWriteMap(/*num_pairs=*/623, &out);
249 CborWriteArray(/*num_elements=*/70000, &out);
250 EXPECT_EQ(nullptr, CborAllocTstr(8, &out));
251 CborWriteTstr("length", &out);
252 EXPECT_EQ(nullptr, CborAllocBstr(1, &out));
253 CborWriteBstr(sizeof(kData), kData, &out);
254 CborWriteInt(-10002000, &out);
255 // Measurement has occurred, but output did not.
256 EXPECT_TRUE(CborOutOverflowed(&out));
257 // Offset is the cumulative size.
258 EXPECT_EQ(1 + 1 + 1 + 3 + 5 + 9 + 7 + 2 + 8 + 5u, CborOutSize(&out));
259 }
260
TEST(CborWriterTest,BufferTooSmall)261 TEST(CborWriterTest, BufferTooSmall) {
262 const uint8_t kData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
263 uint8_t buffer[1];
264 CborOut out;
265 CborOutInit(buffer, sizeof(buffer), &out);
266 // Reset offset each time as it may be corrupted on failures.
267 CborOutInit(buffer, sizeof(buffer), &out);
268 CborWriteInt(-55667788, &out);
269 EXPECT_TRUE(CborOutOverflowed(&out));
270 CborOutInit(buffer, sizeof(buffer), &out);
271 CborWriteBstr(sizeof(kData), kData, &out);
272 EXPECT_TRUE(CborOutOverflowed(&out));
273 CborOutInit(buffer, sizeof(buffer), &out);
274 EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
275 EXPECT_TRUE(CborOutOverflowed(&out));
276 CborOutInit(buffer, sizeof(buffer), &out);
277 CborWriteTstr("Buffer too small", &out);
278 EXPECT_TRUE(CborOutOverflowed(&out));
279 CborOutInit(buffer, sizeof(buffer), &out);
280 EXPECT_EQ(nullptr, CborAllocTstr(16, &out));
281 EXPECT_TRUE(CborOutOverflowed(&out));
282 CborOutInit(buffer, sizeof(buffer), &out);
283 CborWriteArray(/*num_elements=*/563, &out);
284 EXPECT_TRUE(CborOutOverflowed(&out));
285 CborOutInit(buffer, sizeof(buffer), &out);
286 CborWriteMap(/*num_pairs=*/29, &out);
287 EXPECT_TRUE(CborOutOverflowed(&out));
288 CborOutInit(buffer, 0, &out);
289 CborWriteFalse(&out);
290 EXPECT_TRUE(CborOutOverflowed(&out));
291 CborOutInit(buffer, 0, &out);
292 CborWriteTrue(&out);
293 EXPECT_TRUE(CborOutOverflowed(&out));
294 CborOutInit(buffer, 0, &out);
295 CborWriteNull(&out);
296 EXPECT_TRUE(CborOutOverflowed(&out));
297 }
298
TEST(CborWriterTest,NotEnoughRemainingSpace)299 TEST(CborWriterTest, NotEnoughRemainingSpace) {
300 const uint8_t kData[] = {0xff, 0xee, 0xdd, 0xcc};
301 uint8_t zeros[64] = {0};
302 uint8_t buffer[64];
303 CborOut out;
304 CborOutInit(buffer, sizeof(buffer), &out);
305 CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
306 CborWriteInt(-36, &out);
307 EXPECT_TRUE(CborOutOverflowed(&out));
308 CborOutInit(buffer, sizeof(buffer), &out);
309 CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
310 CborWriteBstr(sizeof(kData), kData, &out);
311 EXPECT_TRUE(CborOutOverflowed(&out));
312 CborOutInit(buffer, sizeof(buffer), &out);
313 CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
314 EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
315 EXPECT_TRUE(CborOutOverflowed(&out));
316 CborOutInit(buffer, sizeof(buffer), &out);
317 CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
318 CborWriteTstr("Won't fit", &out);
319 EXPECT_TRUE(CborOutOverflowed(&out));
320 CborOutInit(buffer, sizeof(buffer), &out);
321 CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
322 EXPECT_EQ(nullptr, CborAllocTstr(4, &out));
323 EXPECT_TRUE(CborOutOverflowed(&out));
324 CborOutInit(buffer, sizeof(buffer), &out);
325 CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
326 CborWriteArray(/*num_elements=*/352, &out);
327 EXPECT_TRUE(CborOutOverflowed(&out));
328 CborOutInit(buffer, sizeof(buffer), &out);
329 CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
330 CborWriteMap(/*num_pairs=*/73, &out);
331 EXPECT_TRUE(CborOutOverflowed(&out));
332 CborOutInit(buffer, sizeof(buffer), &out);
333 CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
334 CborWriteFalse(&out);
335 EXPECT_TRUE(CborOutOverflowed(&out));
336 CborOutInit(buffer, sizeof(buffer), &out);
337 CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
338 CborWriteTrue(&out);
339 EXPECT_TRUE(CborOutOverflowed(&out));
340 CborOutInit(buffer, sizeof(buffer), &out);
341 CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
342 CborWriteNull(&out);
343 EXPECT_TRUE(CborOutOverflowed(&out));
344 }
345
TEST(CborWriterTest,OffsetOverflow)346 TEST(CborWriterTest, OffsetOverflow) {
347 const uint8_t kData[] = {0xff, 0xee, 0xdd, 0xcc};
348 uint8_t buffer[64];
349 CborOut out;
350 CborOutInit(buffer, sizeof(buffer), &out);
351 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
352 CborWriteInt(0x234198adb, &out);
353 EXPECT_TRUE(CborOutOverflowed(&out));
354 CborOutInit(buffer, sizeof(buffer), &out);
355 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
356 CborWriteBstr(sizeof(kData), kData, &out);
357 EXPECT_TRUE(CborOutOverflowed(&out));
358 CborOutInit(buffer, sizeof(buffer), &out);
359 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
360 EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
361 EXPECT_TRUE(CborOutOverflowed(&out));
362 CborOutInit(buffer, sizeof(buffer), &out);
363 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
364 CborWriteTstr("Overflow", &out);
365 EXPECT_TRUE(CborOutOverflowed(&out));
366 CborOutInit(buffer, sizeof(buffer), &out);
367 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
368 EXPECT_EQ(nullptr, CborAllocTstr(4, &out));
369 EXPECT_TRUE(CborOutOverflowed(&out));
370 CborOutInit(buffer, sizeof(buffer), &out);
371 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
372 CborWriteArray(/*num_elements=*/41, &out);
373 EXPECT_TRUE(CborOutOverflowed(&out));
374 CborOutInit(buffer, sizeof(buffer), &out);
375 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
376 CborWriteMap(/*num_pairs=*/998844, &out);
377 EXPECT_TRUE(CborOutOverflowed(&out));
378 CborOutInit(buffer, sizeof(buffer), &out);
379 CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
380 CborWriteFalse(&out);
381 EXPECT_TRUE(CborOutOverflowed(&out));
382 CborOutInit(buffer, sizeof(buffer), &out);
383 CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
384 CborWriteTrue(&out);
385 EXPECT_TRUE(CborOutOverflowed(&out));
386 CborOutInit(buffer, sizeof(buffer), &out);
387 CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
388 CborWriteNull(&out);
389 EXPECT_TRUE(CborOutOverflowed(&out));
390 }
391
TEST(CborWriterTest,MeasurementOffsetOverflow)392 TEST(CborWriterTest, MeasurementOffsetOverflow) {
393 const uint8_t kData[] = {0xf0, 0x0f, 0xca, 0xfe, 0xfe, 0xed};
394 CborOut out;
395 CborOutInit(nullptr, 0, &out);
396 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
397 CborWriteInt(0x1419823646241245, &out);
398 EXPECT_TRUE(CborOutOverflowed(&out));
399 CborOutInit(nullptr, 0, &out);
400 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
401 CborWriteBstr(sizeof(kData), kData, &out);
402 EXPECT_TRUE(CborOutOverflowed(&out));
403 CborOutInit(nullptr, 0, &out);
404 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
405 EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
406 EXPECT_TRUE(CborOutOverflowed(&out));
407 CborOutInit(nullptr, 0, &out);
408 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
409 CborWriteTstr("Measured overflow", &out);
410 EXPECT_TRUE(CborOutOverflowed(&out));
411 CborOutInit(nullptr, 0, &out);
412 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
413 EXPECT_EQ(nullptr, CborAllocTstr(6, &out));
414 EXPECT_TRUE(CborOutOverflowed(&out));
415 CborOutInit(nullptr, 0, &out);
416 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
417 CborWriteArray(/*num_elements=*/4073290018, &out);
418 EXPECT_TRUE(CborOutOverflowed(&out));
419 CborOutInit(nullptr, 0, &out);
420 CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
421 CborWriteMap(/*num_pairs=*/92, &out);
422 EXPECT_TRUE(CborOutOverflowed(&out));
423 CborOutInit(nullptr, 0, &out);
424 CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
425 CborWriteFalse(&out);
426 EXPECT_TRUE(CborOutOverflowed(&out));
427 CborOutInit(nullptr, 0, &out);
428 CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
429 CborWriteTrue(&out);
430 EXPECT_TRUE(CborOutOverflowed(&out));
431 CborOutInit(nullptr, 0, &out);
432 CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
433 CborWriteNull(&out);
434 EXPECT_TRUE(CborOutOverflowed(&out));
435 }
436 }
437
438 } // namespace
439