blob: aa4201345fda3db9675855e227b4224f064666f4 [file] [log] [blame]
Laurence Lundbladef156fb82018-10-01 09:47:03 -07001/*==============================================================================
2 run_tests.c -- test aggregator and results reporting
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003
Laurence Lundbladeee851742020-01-08 08:37:05 -08004 Copyright (c) 2018-2020, Laurence Lundblade. All rights reserved.
Laurence Lundblade035bd782019-01-21 17:01:31 -08005
Laurence Lundbladea3fd49f2019-01-21 10:16:22 -08006 SPDX-License-Identifier: BSD-3-Clause
Laurence Lundblade035bd782019-01-21 17:01:31 -08007
Laurence Lundbladea3fd49f2019-01-21 10:16:22 -08008 See BSD-3-Clause license in README.md
Laurence Lundbladef156fb82018-10-01 09:47:03 -07009
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -080010 Created on 9/30/18
Laurence Lundbladeee851742020-01-08 08:37:05 -080011 =============================================================================*/
Laurence Lundbladef156fb82018-10-01 09:47:03 -070012
Laurence Lundbladef156fb82018-10-01 09:47:03 -070013#include "run_tests.h"
14#include "UsefulBuf.h"
15#include <stdbool.h>
16
Laurence Lundblade2d85ce42018-10-12 14:12:47 +080017#include "float_tests.h"
Laurence Lundblade9e3651c2018-10-10 11:49:55 +080018#include "qcbor_decode_tests.h"
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053019#include "qcbor_encode_tests.h"
20#include "UsefulBuf_Tests.h"
Laurence Lundbladef156fb82018-10-01 09:47:03 -070021
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -080022
Laurence Lundbladef156fb82018-10-01 09:47:03 -070023/*
Laurence Lundbladea65b4822019-09-08 12:17:03 -070024 Test configuration
25 */
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -080026
Laurence Lundbladec5fef682020-01-25 11:38:45 -080027typedef int32_t (test_fun_t)(void);
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053028typedef const char * (test_fun2_t)(void);
29
Laurence Lundbladef156fb82018-10-01 09:47:03 -070030
Laurence Lundbladea2e29072018-12-30 09:20:06 -080031#define TEST_ENTRY(test_name) {#test_name, test_name, true}
32#define TEST_ENTRY_DISABLED(test_name) {#test_name, test_name, false}
33
Laurence Lundbladef156fb82018-10-01 09:47:03 -070034typedef struct {
Laurence Lundbladea2e29072018-12-30 09:20:06 -080035 const char *szTestName;
Laurence Lundbladef156fb82018-10-01 09:47:03 -070036 test_fun_t *test_fun;
Laurence Lundbladea2e29072018-12-30 09:20:06 -080037 bool bEnabled;
Laurence Lundbladef156fb82018-10-01 09:47:03 -070038} test_entry;
39
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053040typedef struct {
41 const char *szTestName;
42 test_fun2_t *test_fun;
Laurence Lundbladea2e29072018-12-30 09:20:06 -080043 bool bEnabled;
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053044} test_entry2;
45
Laurence Lundbladea65b4822019-09-08 12:17:03 -070046
47static test_entry2 s_tests2[] = {
Laurence Lundblade7566b9f2018-10-12 09:13:32 +080048 TEST_ENTRY(UBUTest_CopyUtil),
49 TEST_ENTRY(UOBTest_NonAdversarial),
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053050 TEST_ENTRY(TestBasicSanity),
Laurence Lundblade7566b9f2018-10-12 09:13:32 +080051 TEST_ENTRY(UOBTest_BoundaryConditionsTest),
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053052 TEST_ENTRY(UBMacroConversionsTest),
53 TEST_ENTRY(UBUtilTests),
Laurence Lundblade7566b9f2018-10-12 09:13:32 +080054 TEST_ENTRY(UIBTest_IntegerFormat)
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053055};
56
57
Laurence Lundbladea65b4822019-09-08 12:17:03 -070058static test_entry s_tests[] = {
Laurence Lundblade0750fc42020-06-20 21:02:34 -070059 TEST_ENTRY(EnterBstrTest),
Laurence Lundblade9c905e82020-04-25 11:31:38 -070060 TEST_ENTRY(IntegerConvertTest),
Laurence Lundbladebb87be22020-04-09 19:15:32 -070061 TEST_ENTRY(EnterMapTest),
Laurence Lundbladec9f0fbc2020-02-07 10:48:33 +000062 TEST_ENTRY(QCBORHeadTest),
Laurence Lundblade9916b1b2019-09-07 22:33:25 -070063 TEST_ENTRY(EmptyMapsAndArraysTest),
Laurence Lundbladebb1062e2019-08-12 23:28:54 -070064 TEST_ENTRY(NotWellFormedTests),
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +090065 TEST_ENTRY(ParseMapAsArrayTest),
Laurence Lundbladea44d5062018-10-17 18:45:12 +053066 TEST_ENTRY(AllocAllStringsTest),
67 TEST_ENTRY(IndefiniteLengthNestTest),
68 TEST_ENTRY(NestedMapTestIndefLen),
69 TEST_ENTRY(ParseSimpleTest),
Laurence Lundblade3a6042e2019-06-28 19:58:04 -070070 TEST_ENTRY(DecodeFailureTests),
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +080071 TEST_ENTRY(EncodeRawTest),
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053072 TEST_ENTRY(RTICResultsTest),
73 TEST_ENTRY(MapEncodeTest),
74 TEST_ENTRY(ArrayNestingTest1),
75 TEST_ENTRY(ArrayNestingTest2),
Laurence Lundbladed8e1c512020-11-04 23:03:44 -080076#ifndef QCBOR_DISABLE_ENCODE_USAGE_GUARDS
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053077 TEST_ENTRY(ArrayNestingTest3),
Laurence Lundbladed8e1c512020-11-04 23:03:44 -080078#endif /* QCBOR_DISABLE_ENCODE_USAGE_GUARDS */
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +053079 TEST_ENTRY(EncodeDateTest),
80 TEST_ENTRY(SimpleValuesTest1),
81 TEST_ENTRY(IntegerValuesTest1),
82 TEST_ENTRY(AllAddMethodsTest),
Laurence Lundblade9e3651c2018-10-10 11:49:55 +080083 TEST_ENTRY(ParseTooDeepArrayTest),
84 TEST_ENTRY(ComprehensiveInputTest),
85 TEST_ENTRY(ParseMapTest),
Laurence Lundbladea44d5062018-10-17 18:45:12 +053086 TEST_ENTRY(IndefiniteLengthArrayMapTest),
Laurence Lundblade369b90a2018-10-22 02:04:37 +053087 TEST_ENTRY(BasicEncodeTest),
Laurence Lundblade9e3651c2018-10-10 11:49:55 +080088 TEST_ENTRY(NestedMapTest),
89 TEST_ENTRY(BignumParseTest),
90 TEST_ENTRY(OptTagParseTest),
91 TEST_ENTRY(DateParseTest),
Laurence Lundbladec7114722020-08-13 05:11:40 -070092 TEST_ENTRY(SpiffyDateDecodeTest),
Laurence Lundblade9e3651c2018-10-10 11:49:55 +080093 TEST_ENTRY(ShortBufferParseTest2),
94 TEST_ENTRY(ShortBufferParseTest),
95 TEST_ENTRY(ParseDeepArrayTest),
96 TEST_ENTRY(SimpleArrayTest),
97 TEST_ENTRY(IntegerValuesParseTest),
Laurence Lundbladea44d5062018-10-17 18:45:12 +053098 TEST_ENTRY(MemPoolTest),
99 TEST_ENTRY(IndefiniteLengthStringTest),
Laurence Lundbladeb275cdc2020-07-12 12:34:38 -0700100#ifndef QCBOR_DISABLE_PREFERRED_FLOAT
Laurence Lundbladebb474be2018-10-22 11:53:21 +0530101 TEST_ENTRY(HalfPrecisionDecodeBasicTests),
Laurence Lundbladebb474be2018-10-22 11:53:21 +0530102 TEST_ENTRY(DoubleAsSmallestTest),
103 TEST_ENTRY(HalfPrecisionAgainstRFCCodeTest),
Laurence Lundbladeb275cdc2020-07-12 12:34:38 -0700104#endif /* QCBOR_DISABLE_PREFERRED_FLOAT */
Laurence Lundblade585127a2020-07-15 03:25:24 -0700105 TEST_ENTRY(GeneralFloatEncodeTests),
Laurence Lundblade02fcf312020-07-17 02:49:46 -0700106 TEST_ENTRY(GeneralFloatDecodeTests),
Laurence Lundblade369b90a2018-10-22 02:04:37 +0530107 TEST_ENTRY(BstrWrapTest),
108 TEST_ENTRY(BstrWrapErrorTest),
109 TEST_ENTRY(BstrWrapNestTest),
110 TEST_ENTRY(CoseSign1TBSTest),
Laurence Lundbladeea567ac2018-12-09 14:03:21 -0800111 TEST_ENTRY(StringDecoderModeFailTest),
Laurence Lundbladea2e29072018-12-30 09:20:06 -0800112 TEST_ENTRY_DISABLED(BigComprehensiveInputTest),
Laurence Lundbladea4308a82020-10-03 18:08:57 -0700113 TEST_ENTRY_DISABLED(TooLargeInputTest),
Laurence Lundblade1ef8b2d2018-12-14 23:13:34 -0800114 TEST_ENTRY(EncodeErrorTests),
Laurence Lundblade1d7eb632019-02-17 17:23:38 -0800115 TEST_ENTRY(SetUpAllocatorTest),
Jan Jongboom47d86c52019-07-25 08:54:16 +0200116 TEST_ENTRY(SimpleValuesIndefiniteLengthTest1),
Jan Jongboom5d827882019-08-07 12:51:15 +0200117 TEST_ENTRY(EncodeLengthThirtyoneTest),
Laurence Lundbladee3553422020-05-02 11:11:17 -0700118 TEST_ENTRY(CBORSequenceDecodeTests),
Laurence Lundbladee15326f2020-06-15 15:50:23 -0700119 TEST_ENTRY(IntToTests),
Laurence Lundblade37f46e52020-08-04 03:32:14 -0700120 TEST_ENTRY(DecodeTaggedTypeTests),
Laurence Lundblade2a26abb2020-11-05 19:06:54 -0800121 TEST_ENTRY(PeekTest),
Laurence Lundblade59289e52019-12-30 13:44:37 -0800122#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
123 TEST_ENTRY(EncodeLengthThirtyoneTest),
124 TEST_ENTRY(ExponentAndMantissaDecodeTests),
125 TEST_ENTRY(ExponentAndMantissaDecodeFailTests),
126 TEST_ENTRY(ExponentAndMantissaEncodeTests),
Laurence Lundbladeb6d1c692020-10-07 18:37:48 -0700127 TEST_ENTRY(SpiffyIndefiniteLengthStringsTests),
Laurence Lundblade59289e52019-12-30 13:44:37 -0800128#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700129};
130
131
Laurence Lundbladea65b4822019-09-08 12:17:03 -0700132
133
134/*
135 Convert a number up to 999999999 to a string. This is so sprintf doesn't
136 have to be linked in so as to minimized dependencies even in test code.
Laurence Lundblade6216b1b2019-09-27 11:24:39 +0900137
138 StringMem should be 12 bytes long, 9 for digits, 1 for minus and
139 1 for \0 termination.
Laurence Lundbladea65b4822019-09-08 12:17:03 -0700140 */
141static const char *NumToString(int32_t nNum, UsefulBuf StringMem)
142{
143 const int32_t nMax = 1000000000;
144
145 UsefulOutBuf OutBuf;
146 UsefulOutBuf_Init(&OutBuf, StringMem);
147
148 if(nNum < 0) {
149 UsefulOutBuf_AppendByte(&OutBuf, '-');
150 nNum = -nNum;
151 }
152 if(nNum > nMax-1) {
153 return "XXX";
154 }
155
156 bool bDidSomeOutput = false;
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800157 for(int32_t n = nMax; n > 0; n/=10) {
158 int nDigitValue = nNum/n;
159 if(nDigitValue || bDidSomeOutput){
Laurence Lundbladea65b4822019-09-08 12:17:03 -0700160 bDidSomeOutput = true;
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800161 UsefulOutBuf_AppendByte(&OutBuf, (uint8_t)('0' + nDigitValue));
162 nNum -= nDigitValue * n;
Laurence Lundbladea65b4822019-09-08 12:17:03 -0700163 }
164 }
165 if(!bDidSomeOutput){
166 UsefulOutBuf_AppendByte(&OutBuf, '0');
167 }
168 UsefulOutBuf_AppendByte(&OutBuf, '\0');
169
170 return UsefulOutBuf_GetError(&OutBuf) ? "" : StringMem.ptr;
171}
172
173
174/*
175 Public function. See run_test.h.
176 */
Laurence Lundblade29501b72020-01-16 15:05:18 -0800177int RunTestsQCBOR(const char *szTestNames[],
Laurence Lundbladeee851742020-01-08 08:37:05 -0800178 OutputStringCB pfOutput,
179 void *poutCtx,
180 int *pNumTestsRun)
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700181{
182 int nTestsFailed = 0;
183 int nTestsRun = 0;
Laurence Lundblade59289e52019-12-30 13:44:37 -0800184
Laurence Lundblade6216b1b2019-09-27 11:24:39 +0900185 UsefulBuf_MAKE_STACK_UB(StringStorage, 12);
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +0530186
187 test_entry2 *t2;
188 const test_entry2 *s_tests2_end = s_tests2 + sizeof(s_tests2)/sizeof(test_entry2);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800189
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +0530190 for(t2 = s_tests2; t2 < s_tests2_end; t2++) {
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800191 if(szTestNames[0]) {
192 // Some tests have been named
193 const char **szRequestedNames;
194 for(szRequestedNames = szTestNames; *szRequestedNames; szRequestedNames++) {
195 if(!strcmp(t2->szTestName, *szRequestedNames)) {
196 break; // Name matched
197 }
198 }
199 if(*szRequestedNames == NULL) {
200 // Didn't match this test
201 continue;
202 }
203 } else {
204 // no tests named, but don't run "disabled" tests
205 if(!t2->bEnabled) {
206 // Don't run disabled tests when all tests are being run
207 // as indicated by no specific test names being given
208 continue;
209 }
Laurence Lundbladea2e29072018-12-30 09:20:06 -0800210 }
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800211
Laurence Lundbladea2e29072018-12-30 09:20:06 -0800212 const char * szTestResult = (t2->test_fun)();
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +0530213 nTestsRun++;
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800214 if(pfOutput) {
Laurence Lundbladed396f622019-01-12 17:12:29 -0800215 (*pfOutput)(t2->szTestName, poutCtx, 0);
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +0530216 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800217
Laurence Lundbladea2e29072018-12-30 09:20:06 -0800218 if(szTestResult) {
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800219 if(pfOutput) {
Laurence Lundbladed396f622019-01-12 17:12:29 -0800220 (*pfOutput)(" FAILED (returned ", poutCtx, 0);
221 (*pfOutput)(szTestResult, poutCtx, 0);
Laurence Lundbladedf1c1cf2019-01-17 11:55:05 -0800222 (*pfOutput)(")", poutCtx, 1);
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +0530223 }
224 nTestsFailed++;
225 } else {
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800226 if(pfOutput) {
Laurence Lundbladed396f622019-01-12 17:12:29 -0800227 (*pfOutput)( " PASSED", poutCtx, 1);
Laurence Lundbladedc6e28e2018-10-11 19:19:27 +0530228 }
229 }
230 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800231
232
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700233 test_entry *t;
234 const test_entry *s_tests_end = s_tests + sizeof(s_tests)/sizeof(test_entry);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800235
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700236 for(t = s_tests; t < s_tests_end; t++) {
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800237 if(szTestNames[0]) {
238 // Some tests have been named
239 const char **szRequestedNames;
240 for(szRequestedNames = szTestNames; *szRequestedNames; szRequestedNames++) {
241 if(!strcmp(t->szTestName, *szRequestedNames)) {
242 break; // Name matched
243 }
244 }
245 if(*szRequestedNames == NULL) {
246 // Didn't match this test
247 continue;
248 }
249 } else {
250 // no tests named, but don't run "disabled" tests
251 if(!t->bEnabled) {
252 // Don't run disabled tests when all tests are being run
253 // as indicated by no specific test names being given
254 continue;
255 }
Laurence Lundbladea2e29072018-12-30 09:20:06 -0800256 }
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800257
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800258 int32_t nTestResult = (t->test_fun)();
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700259 nTestsRun++;
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800260 if(pfOutput) {
Laurence Lundbladed396f622019-01-12 17:12:29 -0800261 (*pfOutput)(t->szTestName, poutCtx, 0);
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700262 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800263
Laurence Lundbladea2e29072018-12-30 09:20:06 -0800264 if(nTestResult) {
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800265 if(pfOutput) {
Laurence Lundbladed396f622019-01-12 17:12:29 -0800266 (*pfOutput)(" FAILED (returned ", poutCtx, 0);
267 (*pfOutput)(NumToString(nTestResult, StringStorage), poutCtx, 0);
268 (*pfOutput)(")", poutCtx, 1);
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700269 }
270 nTestsFailed++;
271 } else {
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800272 if(pfOutput) {
Laurence Lundbladed396f622019-01-12 17:12:29 -0800273 (*pfOutput)( " PASSED", poutCtx, 1);
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700274 }
275 }
276 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800277
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700278 if(pNumTestsRun) {
279 *pNumTestsRun = nTestsRun;
280 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800281
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800282 if(pfOutput) {
Laurence Lundbladed396f622019-01-12 17:12:29 -0800283 (*pfOutput)( "SUMMARY: ", poutCtx, 0);
284 (*pfOutput)( NumToString(nTestsRun, StringStorage), poutCtx, 0);
285 (*pfOutput)( " tests run; ", poutCtx, 0);
286 (*pfOutput)( NumToString(nTestsFailed, StringStorage), poutCtx, 0);
287 (*pfOutput)( " tests failed", poutCtx, 1);
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700288 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800289
Laurence Lundbladef156fb82018-10-01 09:47:03 -0700290 return nTestsFailed;
291}
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800292
293
Laurence Lundblade844bb5c2020-03-01 17:27:25 -0800294// For size printing
295#include "qcbor/qcbor_encode.h"
296#include "qcbor/qcbor_decode.h"
Laurence Lundbladec384d4e2020-10-07 09:46:10 -0700297#include "qcbor/qcbor_spiffy_decode.h"
Laurence Lundblade844bb5c2020-03-01 17:27:25 -0800298
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800299
Laurence Lundbladea65b4822019-09-08 12:17:03 -0700300/*
301 Public function. See run_test.h.
302 */
Laurence Lundbladeee851742020-01-08 08:37:05 -0800303static void PrintSize(const char *szWhat,
304 uint32_t uSize,
305 OutputStringCB pfOutput,
306 void *pOutCtx)
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800307{
Laurence Lundbladed396f622019-01-12 17:12:29 -0800308 UsefulBuf_MAKE_STACK_UB(buffer, 20);
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800309
Laurence Lundbladed396f622019-01-12 17:12:29 -0800310 (*pfOutput)(szWhat, pOutCtx, 0);
311 (*pfOutput)(" ", pOutCtx, 0);
Laurence Lundblade06350ea2020-01-27 19:32:40 -0800312 (*pfOutput)(NumToString((int32_t)uSize, buffer), pOutCtx, 0);
Laurence Lundbladed396f622019-01-12 17:12:29 -0800313 (*pfOutput)("", pOutCtx, 1);
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800314}
315
Laurence Lundbladea65b4822019-09-08 12:17:03 -0700316
317/*
318 Public function. See run_test.h.
319 */
Laurence Lundblade29501b72020-01-16 15:05:18 -0800320void PrintSizesQCBOR(OutputStringCB pfOutput, void *pOutCtx)
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800321{
Laurence Lundbladeee851742020-01-08 08:37:05 -0800322 // These will never be large so cast is safe
323 PrintSize("sizeof(QCBORTrackNesting)", (uint32_t)sizeof(QCBORTrackNesting), pfOutput, pOutCtx);
Laurence Lundbladed396f622019-01-12 17:12:29 -0800324 PrintSize("sizeof(QCBOREncodeContext)", (uint32_t)sizeof(QCBOREncodeContext), pfOutput, pOutCtx);
325 PrintSize("sizeof(QCBORDecodeNesting)", (uint32_t)sizeof(QCBORDecodeNesting), pfOutput, pOutCtx);
326 PrintSize("sizeof(QCBORDecodeContext)", (uint32_t)sizeof(QCBORDecodeContext), pfOutput, pOutCtx);
Laurence Lundbladeee851742020-01-08 08:37:05 -0800327 PrintSize("sizeof(QCBORItem)", (uint32_t)sizeof(QCBORItem), pfOutput, pOutCtx);
328 PrintSize("sizeof(QCBORTagListIn)", (uint32_t)sizeof(QCBORTagListIn), pfOutput, pOutCtx);
329 PrintSize("sizeof(QCBORTagListOut)", (uint32_t)sizeof(QCBORTagListOut), pfOutput, pOutCtx);
Laurence Lundbladec384d4e2020-10-07 09:46:10 -0700330 PrintSize("sizeof(TagSpecification)", (uint32_t)sizeof(TagSpecification), pfOutput, pOutCtx);
Laurence Lundbladed396f622019-01-12 17:12:29 -0800331 (*pfOutput)("", pOutCtx, 1);
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800332}