xref: /aosp_15_r20/external/open-dice/src/cbor_writer_test.cc (revision 60b67249c2e226f42f35cc6cfe66c6048e0bae6b) 
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,TagEncoding)191 TEST(CborWriterTest, TagEncoding) {
192   const uint8_t kExpectedEncoding[] = {0xcf, 0xd8, 0x18, 0xd9, 0xd9, 0xf8, 0xda,
193                                        0x4f, 0x50, 0x53, 0x4e, 0xdb, 0x10, 0x00,
194                                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
195   uint8_t buffer[64];
196   CborOut out;
197   CborOutInit(buffer, sizeof(buffer), &out);
198   CborWriteTag(/*tag=*/15, &out);
199   CborWriteTag(/*tag=*/24, &out);
200   CborWriteTag(/*tag=*/0xd9f8u, &out);
201   CborWriteTag(/*tag=*/0x4f50534eu, &out);
202   CborWriteTag(/*tag=*/0x1000000000000000u, &out);
203   EXPECT_FALSE(CborOutOverflowed(&out));
204   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
205 }
206 
TEST(CborWriterTest,FalseEncoding)207 TEST(CborWriterTest, FalseEncoding) {
208   const uint8_t kExpectedEncoding[] = {0xf4};
209   uint8_t buffer[64];
210   CborOut out;
211   CborOutInit(buffer, sizeof(buffer), &out);
212   CborWriteFalse(&out);
213   EXPECT_FALSE(CborOutOverflowed(&out));
214   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
215 }
216 
TEST(CborWriterTest,TrueEncoding)217 TEST(CborWriterTest, TrueEncoding) {
218   const uint8_t kExpectedEncoding[] = {0xf5};
219   uint8_t buffer[64];
220   CborOut out;
221   CborOutInit(buffer, sizeof(buffer), &out);
222   CborWriteTrue(&out);
223   EXPECT_FALSE(CborOutOverflowed(&out));
224   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
225 }
226 
TEST(CborWriterTest,NullEncoding)227 TEST(CborWriterTest, NullEncoding) {
228   const uint8_t kExpectedEncoding[] = {0xf6};
229   uint8_t buffer[64];
230   CborOut out;
231   CborOutInit(buffer, sizeof(buffer), &out);
232   CborWriteNull(&out);
233   EXPECT_FALSE(CborOutOverflowed(&out));
234   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
235 }
236 
TEST(CborWriterTest,CborOutInvariants)237 TEST(CborWriterTest, CborOutInvariants) {
238   const uint8_t kData[] = {0xb2, 0x34, 0x75, 0x92, 0x52};
239   uint8_t buffer[64];
240   CborOut out;
241   CborOutInit(buffer, sizeof(buffer), &out);
242   CborWriteInt(0xab34, &out);
243   CborWriteBstr(sizeof(kData), kData, &out);
244   EXPECT_NE(nullptr, CborAllocBstr(7, &out));
245   CborWriteTstr("A string", &out);
246   EXPECT_NE(nullptr, CborAllocTstr(6, &out));
247   CborWriteArray(/*num_elements=*/16, &out);
248   CborWriteMap(/*num_pairs=*/35, &out);
249   CborWriteTag(/*tag=*/15, &out);
250   CborWriteFalse(&out);
251   CborWriteTrue(&out);
252   CborWriteNull(&out);
253   EXPECT_FALSE(CborOutOverflowed(&out));
254   // Offset is the cumulative size.
255   EXPECT_EQ(3 + 6 + 8 + 9 + 7 + 1 + 2 + 1 + 1 + 1 + 1u, CborOutSize(&out));
256 }
257 
TEST(CborWriterTest,NullBufferForMeasurement)258 TEST(CborWriterTest, NullBufferForMeasurement) {
259   const uint8_t kData[] = {16, 102, 246, 12, 156, 35, 84};
260   CborOut out;
261   CborOutInit(nullptr, 0, &out);
262   CborWriteNull(&out);
263   CborWriteTrue(&out);
264   CborWriteFalse(&out);
265   CborWriteTag(/*tag=*/15, &out);
266   CborWriteMap(/*num_pairs=*/623, &out);
267   CborWriteArray(/*num_elements=*/70000, &out);
268   EXPECT_EQ(nullptr, CborAllocTstr(8, &out));
269   CborWriteTstr("length", &out);
270   EXPECT_EQ(nullptr, CborAllocBstr(1, &out));
271   CborWriteBstr(sizeof(kData), kData, &out);
272   CborWriteInt(-10002000, &out);
273   // Measurement has occurred, but output did not.
274   EXPECT_TRUE(CborOutOverflowed(&out));
275   // Offset is the cumulative size.
276   EXPECT_EQ(1 + 1 + 1 + 1 + 3 + 5 + 9 + 7 + 2 + 8 + 5u, CborOutSize(&out));
277 }
278 
TEST(CborWriterTest,BufferTooSmall)279 TEST(CborWriterTest, BufferTooSmall) {
280   const uint8_t kData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
281   uint8_t buffer[1];
282   CborOut out;
283   CborOutInit(buffer, sizeof(buffer), &out);
284   // Reset offset each time as it may be corrupted on failures.
285   CborOutInit(buffer, sizeof(buffer), &out);
286   CborWriteInt(-55667788, &out);
287   EXPECT_TRUE(CborOutOverflowed(&out));
288   CborOutInit(buffer, sizeof(buffer), &out);
289   CborWriteBstr(sizeof(kData), kData, &out);
290   EXPECT_TRUE(CborOutOverflowed(&out));
291   CborOutInit(buffer, sizeof(buffer), &out);
292   EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
293   EXPECT_TRUE(CborOutOverflowed(&out));
294   CborOutInit(buffer, sizeof(buffer), &out);
295   CborWriteTstr("Buffer too small", &out);
296   EXPECT_TRUE(CborOutOverflowed(&out));
297   CborOutInit(buffer, sizeof(buffer), &out);
298   EXPECT_EQ(nullptr, CborAllocTstr(16, &out));
299   EXPECT_TRUE(CborOutOverflowed(&out));
300   CborOutInit(buffer, sizeof(buffer), &out);
301   CborWriteArray(/*num_elements=*/563, &out);
302   EXPECT_TRUE(CborOutOverflowed(&out));
303   CborOutInit(buffer, sizeof(buffer), &out);
304   CborWriteMap(/*num_pairs=*/29, &out);
305   EXPECT_TRUE(CborOutOverflowed(&out));
306   CborOutInit(buffer, 0, &out);
307   CborWriteFalse(&out);
308   EXPECT_TRUE(CborOutOverflowed(&out));
309   CborOutInit(buffer, 0, &out);
310   CborWriteTrue(&out);
311   EXPECT_TRUE(CborOutOverflowed(&out));
312   CborOutInit(buffer, 0, &out);
313   CborWriteNull(&out);
314   EXPECT_TRUE(CborOutOverflowed(&out));
315 }
316 
TEST(CborWriterTest,NotEnoughRemainingSpace)317 TEST(CborWriterTest, NotEnoughRemainingSpace) {
318   const uint8_t kData[] = {0xff, 0xee, 0xdd, 0xcc};
319   uint8_t zeros[64] = {0};
320   uint8_t buffer[64];
321   CborOut out;
322   CborOutInit(buffer, sizeof(buffer), &out);
323   CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
324   CborWriteInt(-36, &out);
325   EXPECT_TRUE(CborOutOverflowed(&out));
326   CborOutInit(buffer, sizeof(buffer), &out);
327   CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
328   CborWriteBstr(sizeof(kData), kData, &out);
329   EXPECT_TRUE(CborOutOverflowed(&out));
330   CborOutInit(buffer, sizeof(buffer), &out);
331   CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
332   EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
333   EXPECT_TRUE(CborOutOverflowed(&out));
334   CborOutInit(buffer, sizeof(buffer), &out);
335   CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
336   CborWriteTstr("Won't fit", &out);
337   EXPECT_TRUE(CborOutOverflowed(&out));
338   CborOutInit(buffer, sizeof(buffer), &out);
339   CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
340   EXPECT_EQ(nullptr, CborAllocTstr(4, &out));
341   EXPECT_TRUE(CborOutOverflowed(&out));
342   CborOutInit(buffer, sizeof(buffer), &out);
343   CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
344   CborWriteArray(/*num_elements=*/352, &out);
345   EXPECT_TRUE(CborOutOverflowed(&out));
346   CborOutInit(buffer, sizeof(buffer), &out);
347   CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
348   CborWriteMap(/*num_pairs=*/73, &out);
349   EXPECT_TRUE(CborOutOverflowed(&out));
350   CborOutInit(buffer, sizeof(buffer), &out);
351   CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
352   CborWriteFalse(&out);
353   EXPECT_TRUE(CborOutOverflowed(&out));
354   CborOutInit(buffer, sizeof(buffer), &out);
355   CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
356   CborWriteTrue(&out);
357   EXPECT_TRUE(CborOutOverflowed(&out));
358   CborOutInit(buffer, sizeof(buffer), &out);
359   CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
360   CborWriteNull(&out);
361   EXPECT_TRUE(CborOutOverflowed(&out));
362 }
363 
TEST(CborWriterTest,OffsetOverflow)364 TEST(CborWriterTest, OffsetOverflow) {
365   const uint8_t kData[] = {0xff, 0xee, 0xdd, 0xcc};
366   uint8_t buffer[64];
367   CborOut out;
368   CborOutInit(buffer, sizeof(buffer), &out);
369   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
370   CborWriteInt(0x234198adb, &out);
371   EXPECT_TRUE(CborOutOverflowed(&out));
372   CborOutInit(buffer, sizeof(buffer), &out);
373   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
374   CborWriteBstr(sizeof(kData), kData, &out);
375   EXPECT_TRUE(CborOutOverflowed(&out));
376   CborOutInit(buffer, sizeof(buffer), &out);
377   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
378   EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
379   EXPECT_TRUE(CborOutOverflowed(&out));
380   CborOutInit(buffer, sizeof(buffer), &out);
381   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
382   CborWriteTstr("Overflow", &out);
383   EXPECT_TRUE(CborOutOverflowed(&out));
384   CborOutInit(buffer, sizeof(buffer), &out);
385   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
386   EXPECT_EQ(nullptr, CborAllocTstr(4, &out));
387   EXPECT_TRUE(CborOutOverflowed(&out));
388   CborOutInit(buffer, sizeof(buffer), &out);
389   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
390   CborWriteArray(/*num_elements=*/41, &out);
391   EXPECT_TRUE(CborOutOverflowed(&out));
392   CborOutInit(buffer, sizeof(buffer), &out);
393   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
394   CborWriteMap(/*num_pairs=*/998844, &out);
395   EXPECT_TRUE(CborOutOverflowed(&out));
396   CborOutInit(buffer, sizeof(buffer), &out);
397   CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
398   CborWriteFalse(&out);
399   EXPECT_TRUE(CborOutOverflowed(&out));
400   CborOutInit(buffer, sizeof(buffer), &out);
401   CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
402   CborWriteTrue(&out);
403   EXPECT_TRUE(CborOutOverflowed(&out));
404   CborOutInit(buffer, sizeof(buffer), &out);
405   CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
406   CborWriteNull(&out);
407   EXPECT_TRUE(CborOutOverflowed(&out));
408 }
409 
TEST(CborWriterTest,MeasurementOffsetOverflow)410 TEST(CborWriterTest, MeasurementOffsetOverflow) {
411   const uint8_t kData[] = {0xf0, 0x0f, 0xca, 0xfe, 0xfe, 0xed};
412   CborOut out;
413   CborOutInit(nullptr, 0, &out);
414   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
415   CborWriteInt(0x1419823646241245, &out);
416   EXPECT_TRUE(CborOutOverflowed(&out));
417   CborOutInit(nullptr, 0, &out);
418   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
419   CborWriteBstr(sizeof(kData), kData, &out);
420   EXPECT_TRUE(CborOutOverflowed(&out));
421   CborOutInit(nullptr, 0, &out);
422   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
423   EXPECT_EQ(nullptr, CborAllocBstr(sizeof(kData), &out));
424   EXPECT_TRUE(CborOutOverflowed(&out));
425   CborOutInit(nullptr, 0, &out);
426   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
427   CborWriteTstr("Measured overflow", &out);
428   EXPECT_TRUE(CborOutOverflowed(&out));
429   CborOutInit(nullptr, 0, &out);
430   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
431   EXPECT_EQ(nullptr, CborAllocTstr(6, &out));
432   EXPECT_TRUE(CborOutOverflowed(&out));
433   CborOutInit(nullptr, 0, &out);
434   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
435   CborWriteArray(/*num_elements=*/4073290018, &out);
436   EXPECT_TRUE(CborOutOverflowed(&out));
437   CborOutInit(nullptr, 0, &out);
438   CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
439   CborWriteMap(/*num_pairs=*/92, &out);
440   EXPECT_TRUE(CborOutOverflowed(&out));
441   CborOutInit(nullptr, 0, &out);
442   CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
443   CborWriteFalse(&out);
444   EXPECT_TRUE(CborOutOverflowed(&out));
445   CborOutInit(nullptr, 0, &out);
446   CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
447   CborWriteTrue(&out);
448   EXPECT_TRUE(CborOutOverflowed(&out));
449   CborOutInit(nullptr, 0, &out);
450   CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
451   CborWriteNull(&out);
452   EXPECT_TRUE(CborOutOverflowed(&out));
453 }
454 }
455 
456 }  // namespace
457