blob: deb4c6c95f34c569fdaf37a6ea9de2563923ed56 [file] [log] [blame]
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001/*==============================================================================
Laurence Lundbladed92a6162018-11-01 11:38:35 +07002 Copyright (c) 2016-2018, The Linux Foundation.
Laurence Lundbladeee851742020-01-08 08:37:05 -08003 Copyright (c) 2018-2020, Laurence Lundblade.
Laurence Lundbladed92a6162018-11-01 11:38:35 +07004 All rights reserved.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08005
Laurence Lundblade0dbc9172018-11-01 14:17:21 +07006Redistribution and use in source and binary forms, with or without
7modification, are permitted provided that the following conditions are
8met:
9 * Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11 * Redistributions in binary form must reproduce the above
12 copyright notice, this list of conditions and the following
13 disclaimer in the documentation and/or other materials provided
14 with the distribution.
15 * Neither the name of The Linux Foundation nor the names of its
16 contributors, nor the name "Laurence Lundblade" may be used to
17 endorse or promote products derived from this software without
18 specific prior written permission.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -080019
Laurence Lundblade0dbc9172018-11-01 14:17:21 +070020THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
21WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
23ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
24BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
29OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
30IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Laurence Lundbladeee851742020-01-08 08:37:05 -080031 =============================================================================*/
Laurence Lundblade9e3651c2018-10-10 11:49:55 +080032
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080033#include "qcbor_decode_tests.h"
Laurence Lundblade844bb5c2020-03-01 17:27:25 -080034#include "qcbor/qcbor_encode.h"
35#include "qcbor/qcbor_decode.h"
Laurence Lundblade67257dc2020-07-27 03:33:37 -070036#include "qcbor/qcbor_spiffy_decode.h"
Laurence Lundbladed4728fd2018-12-17 15:15:56 -080037#include <string.h>
Laurence Lundblade9e3651c2018-10-10 11:49:55 +080038#include <math.h> // for fabs()
Laurence Lundbladebb1062e2019-08-12 23:28:54 -070039#include "not_well_formed_cbor.h"
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -080040
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080041
Laurence Lundbladea2e29072018-12-30 09:20:06 -080042#ifdef PRINT_FUNCTIONS_FOR_DEBUGGING
Laurence Lundblade20db9c92018-12-17 11:40:37 -080043#include <stdio.h>
Laurence Lundbladea2e29072018-12-30 09:20:06 -080044
45static void PrintUsefulBufC(const char *szLabel, UsefulBufC Buf)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080046{
47 if(szLabel) {
48 printf("%s ", szLabel);
49 }
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -080050
Laurence Lundblade570fab52018-10-13 18:28:27 +080051 size_t i;
Laurence Lundbladea2e29072018-12-30 09:20:06 -080052 for(i = 0; i < Buf.len; i++) {
53 uint8_t Z = ((uint8_t *)Buf.ptr)[i];
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080054 printf("%02x ", Z);
55 }
56 printf("\n");
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -080057
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080058 fflush(stdout);
59}
Laurence Lundblade20db9c92018-12-17 11:40:37 -080060#endif
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080061
62
Laurence Lundbladeb836efb2018-10-28 20:09:58 +070063static const uint8_t spExpectedEncodedInts[] = {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080064 0x98, 0x2f, 0x3b, 0x7f, 0xff, 0xff, 0xff, 0xff,
65 0xff, 0xff, 0xff, 0x3b, 0x00, 0x00, 0x00, 0x01,
66 0x00, 0x00, 0x00, 0x00, 0x3a, 0xff, 0xff, 0xff,
67 0xff, 0x3a, 0xff, 0xff, 0xff, 0xfe, 0x3a, 0xff,
68 0xff, 0xff, 0xfd, 0x3a, 0x7f, 0xff, 0xff, 0xff,
69 0x3a, 0x7f, 0xff, 0xff, 0xfe, 0x3a, 0x00, 0x01,
70 0x00, 0x01, 0x3a, 0x00, 0x01, 0x00, 0x00, 0x39,
71 0xff, 0xff, 0x39, 0xff, 0xfe, 0x39, 0xff, 0xfd,
72 0x39, 0x01, 0x00, 0x38, 0xff, 0x38, 0xfe, 0x38,
73 0xfd, 0x38, 0x18, 0x37, 0x36, 0x20, 0x00, 0x00,
74 0x01, 0x16, 0x17, 0x18, 0x18, 0x18, 0x19, 0x18,
75 0x1a, 0x18, 0xfe, 0x18, 0xff, 0x19, 0x01, 0x00,
76 0x19, 0x01, 0x01, 0x19, 0xff, 0xfe, 0x19, 0xff,
77 0xff, 0x1a, 0x00, 0x01, 0x00, 0x00, 0x1a, 0x00,
78 0x01, 0x00, 0x01, 0x1a, 0x00, 0x01, 0x00, 0x02,
79 0x1a, 0x7f, 0xff, 0xff, 0xff, 0x1a, 0x7f, 0xff,
80 0xff, 0xff, 0x1a, 0x80, 0x00, 0x00, 0x00, 0x1a,
81 0x80, 0x00, 0x00, 0x01, 0x1a, 0xff, 0xff, 0xff,
82 0xfe, 0x1a, 0xff, 0xff, 0xff, 0xff, 0x1b, 0x00,
83 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x1b,
84 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
85 0x1b, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
86 0xff, 0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
87 0xff, 0xff};
88
89
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080090// return CBOR error or -1 if type of value doesn't match
91
Laurence Lundbladec5fef682020-01-25 11:38:45 -080092static int32_t IntegerValuesParseTestInternal(QCBORDecodeContext *pDCtx)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080093{
Laurence Lundbladee6bcef12020-04-01 10:56:27 -070094 QCBORItem Item;
95 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -080096
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080097 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -070098 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +080099 if(Item.uDataType != QCBOR_TYPE_ARRAY)
100 return -1;
101
102 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700103 return (int32_t)nCBORError;
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800104 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade570fab52018-10-13 18:28:27 +0800105 Item.val.int64 != -9223372036854775807LL - 1)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800106 return -1;
107
108 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700109 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800110 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade570fab52018-10-13 18:28:27 +0800111 Item.val.int64 != -4294967297)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800112 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800113
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800114 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700115 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800116 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade570fab52018-10-13 18:28:27 +0800117 Item.val.int64 != -4294967296)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800118 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800119
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800120 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700121 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800122 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade570fab52018-10-13 18:28:27 +0800123 Item.val.int64 != -4294967295)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800124 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800125
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800126 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700127 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800128 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade570fab52018-10-13 18:28:27 +0800129 Item.val.int64 != -4294967294)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800130 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800131
132
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800133 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700134 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800135 if(Item.uDataType != QCBOR_TYPE_INT64 ||
136 Item.val.int64 != -2147483648)
137 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800138
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800139 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700140 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800141 if(Item.uDataType != QCBOR_TYPE_INT64 ||
142 Item.val.int64 != -2147483647)
143 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800144
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800145 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700146 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800147 if(Item.uDataType != QCBOR_TYPE_INT64 ||
148 Item.val.int64 != -65538)
149 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800150
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800151 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700152 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800153 if(Item.uDataType != QCBOR_TYPE_INT64 ||
154 Item.val.int64 != -65537)
155 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800156
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800157 if((nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700158 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800159 if(Item.uDataType != QCBOR_TYPE_INT64 ||
160 Item.val.int64 != -65536)
161 return -1;
162
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800163
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800164 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700165 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800166 if(Item.uDataType != QCBOR_TYPE_INT64 ||
167 Item.val.int64 != -65535)
168 return -1;
169
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800170
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800171 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700172 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800173 if(Item.uDataType != QCBOR_TYPE_INT64 ||
174 Item.val.int64 != -65534)
175 return -1;
176
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800177
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800178 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700179 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800180 if(Item.uDataType != QCBOR_TYPE_INT64 ||
181 Item.val.int64 != -257)
182 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800183
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800184 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700185 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800186 if(Item.uDataType != QCBOR_TYPE_INT64 ||
187 Item.val.int64 != -256)
188 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800189
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800190 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700191 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800192 if(Item.uDataType != QCBOR_TYPE_INT64 ||
193 Item.val.int64 != -255)
194 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800195
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800196 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700197 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800198 if(Item.uDataType != QCBOR_TYPE_INT64 ||
199 Item.val.int64 != -254)
200 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800201
202
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800203 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700204 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800205 if(Item.uDataType != QCBOR_TYPE_INT64 ||
206 Item.val.int64 != -25)
207 return -1;
208
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800209
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800210 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700211 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800212 if(Item.uDataType != QCBOR_TYPE_INT64 ||
213 Item.val.int64 != -24)
214 return -1;
215
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800216
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800217 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700218 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800219 if(Item.uDataType != QCBOR_TYPE_INT64 ||
220 Item.val.int64 != -23)
221 return -1;
222
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800223
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800224 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700225 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800226 if(Item.uDataType != QCBOR_TYPE_INT64 ||
227 Item.val.int64 != -1)
228 return -1;
229
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800230
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800231 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700232 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800233 if(Item.uDataType != QCBOR_TYPE_INT64 ||
234 Item.val.int64 != 0)
235 return -1;
236
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800237
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800238 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700239 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800240 if(Item.uDataType != QCBOR_TYPE_INT64 ||
241 Item.val.int64 != 0)
242 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800243
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800244 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700245 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800246 if(Item.uDataType != QCBOR_TYPE_INT64 ||
247 Item.val.int64 != 1)
248 return -1;
249
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800250
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800251 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700252 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800253 if(Item.uDataType != QCBOR_TYPE_INT64 ||
254 Item.val.int64 != 22)
255 return -1;
256
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800257
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800258 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700259 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800260 if(Item.uDataType != QCBOR_TYPE_INT64 ||
261 Item.val.int64 != 23)
262 return -1;
263
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800264
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800265 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700266 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800267 if(Item.uDataType != QCBOR_TYPE_INT64 ||
268 Item.val.int64 != 24)
269 return -1;
270
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800271
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800272 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700273 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800274 if(Item.uDataType != QCBOR_TYPE_INT64 ||
275 Item.val.int64 != 25)
276 return -1;
277
278 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700279 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800280 if(Item.uDataType != QCBOR_TYPE_INT64 ||
281 Item.val.int64 != 26)
282 return -1;
283
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800284
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800285 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700286 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800287 if(Item.uDataType != QCBOR_TYPE_INT64 ||
288 Item.val.int64 != 254)
289 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800290
291
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800292 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700293 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800294 if(Item.uDataType != QCBOR_TYPE_INT64 ||
295 Item.val.int64 != 255)
296 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800297
298
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800299 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700300 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800301 if(Item.uDataType != QCBOR_TYPE_INT64 ||
302 Item.val.int64 != 256)
303 return -1;
304
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800305
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800306 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700307 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800308 if(Item.uDataType != QCBOR_TYPE_INT64 ||
309 Item.val.int64 != 257)
310 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800311
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800312 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700313 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800314 if(Item.uDataType != QCBOR_TYPE_INT64 ||
315 Item.val.int64 != 65534)
316 return -1;
317
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800318
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800319 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700320 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800321 if(Item.uDataType != QCBOR_TYPE_INT64 ||
322 Item.val.int64 != 65535)
323 return -1;
324
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800325
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800326 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700327 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800328 if(Item.uDataType != QCBOR_TYPE_INT64 ||
329 Item.val.int64 != 65536)
330 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800331
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800332 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700333 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800334 if(Item.uDataType != QCBOR_TYPE_INT64 ||
335 Item.val.int64 != 65537)
336 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800337
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800338 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700339 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800340 if(Item.uDataType != QCBOR_TYPE_INT64 ||
341 Item.val.int64 != 65538)
342 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800343
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800344 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700345 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800346 if(Item.uDataType != QCBOR_TYPE_INT64 ||
347 Item.val.int64 != 2147483647)
348 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800349
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800350 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700351 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800352 if(Item.uDataType != QCBOR_TYPE_INT64 ||
353 Item.val.int64 != 2147483647)
354 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800355
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800356 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700357 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800358 if(Item.uDataType != QCBOR_TYPE_INT64 ||
359 Item.val.int64 != 2147483648)
360 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800361
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800362 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700363 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800364 if(Item.uDataType != QCBOR_TYPE_INT64 ||
365 Item.val.int64 != 2147483649)
366 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800367
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800368 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700369 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800370 if(Item.uDataType != QCBOR_TYPE_INT64 ||
371 Item.val.int64 != 4294967294)
372 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800373
374
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700375 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
376 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800377 if(Item.uDataType != QCBOR_TYPE_INT64 ||
378 Item.val.int64 != 4294967295)
379 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800380
381
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800382 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700383 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800384 if(Item.uDataType != QCBOR_TYPE_INT64 ||
385 Item.val.int64 != 4294967296)
386 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800387
388
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800389 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700390 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800391 if(Item.uDataType != QCBOR_TYPE_INT64 ||
392 Item.val.int64 != 4294967297)
393 return -1;
394
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800395
396
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800397 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700398 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800399 if(Item.uDataType != QCBOR_TYPE_INT64 ||
400 Item.val.int64 != 9223372036854775807LL)
401 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800402
403
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800404 if(( nCBORError = QCBORDecode_GetNext(pDCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700405 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800406 if(Item.uDataType != QCBOR_TYPE_UINT64 ||
407 Item.val.uint64 != 18446744073709551615ULL)
408 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800409
410
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800411 if(QCBORDecode_Finish(pDCtx) != QCBOR_SUCCESS) {
412 return -1;
413 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800414
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800415 return 0;
416}
417
418
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800419// One less than the smallest negative integer allowed in C. Decoding
420// this should fail.
421static const uint8_t spTooSmallNegative[] = {
422 0x3b, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
Laurence Lundblade21d1d812019-09-28 22:47:49 -1000423};
424
425
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800426/*
427 Tests the decoding of lots of different integers sizes
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +0800428 and values.
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800429 */
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800430int32_t IntegerValuesParseTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800431{
Laurence Lundblade21d1d812019-09-28 22:47:49 -1000432 int nReturn;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800433 QCBORDecodeContext DCtx;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800434
Laurence Lundblade21d1d812019-09-28 22:47:49 -1000435 QCBORDecode_Init(&DCtx,
436 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedEncodedInts),
437 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800438
Laurence Lundblade21d1d812019-09-28 22:47:49 -1000439 // The really big test of all successes
440 nReturn = IntegerValuesParseTestInternal(&DCtx);
441 if(nReturn) {
442 return nReturn;
443 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800444
Laurence Lundblade21d1d812019-09-28 22:47:49 -1000445 // The one large negative integer that can be parsed
446 QCBORDecode_Init(&DCtx,
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800447 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spTooSmallNegative),
Laurence Lundblade21d1d812019-09-28 22:47:49 -1000448 QCBOR_DECODE_MODE_NORMAL);
449
450 QCBORItem item;
451 if(QCBORDecode_GetNext(&DCtx, &item) != QCBOR_ERR_INT_OVERFLOW) {
452 nReturn = -4000;
453 }
454
455 return(nReturn);
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800456}
457
458
459/*
Laurence Lundbladeee851742020-01-08 08:37:05 -0800460 Creates a simple CBOR array and returns it in *pEncoded. The array is
461 malloced and needs to be freed. This is used by several tests.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800462
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800463 Two of the inputs can be set. Two other items in the array are fixed.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800464
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800465 */
466
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800467static uint8_t spSimpleArrayBuffer[50];
468
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800469static int32_t CreateSimpleArray(int nInt1, int nInt2, uint8_t **pEncoded, size_t *pEncodedLen)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800470{
471 QCBOREncodeContext ECtx;
472 int nReturn = -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800473
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800474 *pEncoded = NULL;
475 *pEncodedLen = INT32_MAX;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800476
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800477 // loop runs CBOR encoding twice. First with no buffer to
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800478 // calculate the length so buffer can be allocated correctly,
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800479 // and last with the buffer to do the actual encoding
480 do {
Laurence Lundblade0595e932018-11-02 22:22:47 +0700481 QCBOREncode_Init(&ECtx, (UsefulBuf){*pEncoded, *pEncodedLen});
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800482 QCBOREncode_OpenArray(&ECtx);
483 QCBOREncode_AddInt64(&ECtx, nInt1);
484 QCBOREncode_AddInt64(&ECtx, nInt2);
485 QCBOREncode_AddBytes(&ECtx, ((UsefulBufC) {"galactic", 8}));
486 QCBOREncode_AddBytes(&ECtx, ((UsefulBufC) {"haven token", 11}));
487 QCBOREncode_CloseArray(&ECtx);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800488
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800489 if(QCBOREncode_FinishGetSize(&ECtx, pEncodedLen))
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800490 goto Done;
491
492 if(*pEncoded != NULL) {
493 nReturn = 0;
494 goto Done;
495 }
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800496
497 // Use static buffer to avoid dependency on malloc()
498 if(*pEncodedLen > sizeof(spSimpleArrayBuffer)) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800499 goto Done;
500 }
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800501 *pEncoded = spSimpleArrayBuffer;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800502
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800503 } while(1);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800504
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -0800505Done:
506 return nReturn;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800507}
508
509
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800510/*
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800511 Some basic CBOR with map and array used in a lot of tests.
512 The map labels are all strings
513
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800514 {"first integer": 42,
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900515 "an array of two strings": [
516 "string1", "string2"
517 ],
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800518 "map in a map": {
519 "bytes 1": h'78787878',
520 "bytes 2": h'79797979',
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900521 "another int": 98,
522 "text 2": "lies, damn lies and statistics"
523 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800524 }
525 */
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800526static const uint8_t pValidMapEncoded[] = {
Laurence Lundbladeb836efb2018-10-28 20:09:58 +0700527 0xa3, 0x6d, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x69, 0x6e,
528 0x74, 0x65, 0x67, 0x65, 0x72, 0x18, 0x2a, 0x77, 0x61, 0x6e,
529 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20,
530 0x74, 0x77, 0x6f, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
531 0x73, 0x82, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x31,
532 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x6c, 0x6d,
533 0x61, 0x70, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x6d, 0x61,
534 0x70, 0xa4, 0x67, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x31,
535 0x44, 0x78, 0x78, 0x78, 0x78, 0x67, 0x62, 0x79, 0x74, 0x65,
536 0x73, 0x20, 0x32, 0x44, 0x79, 0x79, 0x79, 0x79, 0x6b, 0x61,
537 0x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x74,
538 0x18, 0x62, 0x66, 0x74, 0x65, 0x78, 0x74, 0x20, 0x32, 0x78,
539 0x1e, 0x6c, 0x69, 0x65, 0x73, 0x2c, 0x20, 0x64, 0x61, 0x6d,
540 0x6e, 0x20, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64,
541 0x20, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63,
Laurence Lundblade02625d42020-06-25 14:41:41 -0700542 0x73 };
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800543
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700544// Same as above, but with indefinite lengths.
545static const uint8_t pValidMapIndefEncoded[] = {
5460xbf, 0x6d, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x69, 0x6e,
5470x74, 0x65, 0x67, 0x65, 0x72, 0x18, 0x2a, 0x77, 0x61, 0x6e,
5480x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x6f, 0x66, 0x20,
5490x74, 0x77, 0x6f, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
5500x73, 0x9f, 0x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x31,
5510x67, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0xff, 0x6c, 0x6d,
5520x61, 0x70, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x6d, 0x61,
5530x70, 0xbf, 0x67, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x31,
5540x44, 0x78, 0x78, 0x78, 0x78, 0x67, 0x62, 0x79, 0x74, 0x65,
5550x73, 0x20, 0x32, 0x44, 0x79, 0x79, 0x79, 0x79, 0x6b, 0x61,
5560x6e, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x69, 0x6e, 0x74,
5570x18, 0x62, 0x66, 0x74, 0x65, 0x78, 0x74, 0x20, 0x32, 0x78,
5580x1e, 0x6c, 0x69, 0x65, 0x73, 0x2c, 0x20, 0x64, 0x61, 0x6d,
5590x6e, 0x20, 0x6c, 0x69, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64,
5600x20, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63,
5610x73, 0xff, 0xff};
562
563
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800564static int32_t ParseOrderedArray(const uint8_t *pEncoded,
Laurence Lundblade02625d42020-06-25 14:41:41 -0700565 size_t nLen,
566 int64_t *pInt1,
567 int64_t *pInt2,
568 const uint8_t **pBuf3,
569 size_t *pBuf3Len,
570 const uint8_t **pBuf4,
571 size_t *pBuf4Len)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800572{
573 QCBORDecodeContext DCtx;
574 QCBORItem Item;
575 int nReturn = -1; // assume error until success
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800576
Laurence Lundbladeee851742020-01-08 08:37:05 -0800577 QCBORDecode_Init(&DCtx,
578 (UsefulBufC){pEncoded, nLen},
579 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800580
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800581 // Make sure the first thing is a map
582 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 || Item.uDataType != QCBOR_TYPE_ARRAY)
583 goto Done;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800584
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800585 // First integer
Laurence Lundblade12b495d2018-12-17 11:15:54 -0800586 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 || Item.uDataType != QCBOR_TYPE_INT64)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800587 goto Done;
588 *pInt1 = Item.val.int64;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800589
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800590 // Second integer
591 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 || Item.uDataType != QCBOR_TYPE_INT64)
592 goto Done;
593 *pInt2 = Item.val.int64;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800594
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800595 // First string
596 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 || Item.uDataType != QCBOR_TYPE_BYTE_STRING)
597 goto Done;
598 *pBuf3 = Item.val.string.ptr;
599 *pBuf3Len = Item.val.string.len;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800600
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800601 // Second string
602 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 || Item.uDataType != QCBOR_TYPE_BYTE_STRING)
603 goto Done;
604 *pBuf4 = Item.val.string.ptr;
605 *pBuf4Len = Item.val.string.len;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800606
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800607 nReturn = 0;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800608
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800609Done:
610 return(nReturn);
611}
612
613
614
Laurence Lundblade9e3651c2018-10-10 11:49:55 +0800615
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800616int32_t SimpleArrayTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800617{
618 uint8_t *pEncoded;
619 size_t nEncodedLen;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800620
Laurence Lundblade5e390822019-01-06 12:35:01 -0800621 int64_t i1=0, i2=0;
622 size_t i3=0, i4=0;
623 const uint8_t *s3= (uint8_t *)"";
624 const uint8_t *s4= (uint8_t *)"";
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800625
626
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800627 if(CreateSimpleArray(23, 6000, &pEncoded, &nEncodedLen) < 0) {
628 return(-1);
629 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800630
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800631 ParseOrderedArray(pEncoded, nEncodedLen, &i1, &i2, &s3, &i3, &s4, &i4);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800632
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800633 if(i1 != 23 ||
634 i2 != 6000 ||
635 i3 != 8 ||
636 i4 != 11 ||
Laurence Lundbladea44d5062018-10-17 18:45:12 +0530637 memcmp("galactic", s3, 8) !=0 ||
638 memcmp("haven token", s4, 11) !=0) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800639 return(-1);
640 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800641
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800642 return(0);
643}
644
645
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700646/*
647 [
648 0,
649 [],
650 [
651 [],
652 [
653 0
654 ],
655 {},
656 {
657 1: {},
658 2: {},
659 3: []
660 }
661 ]
662 ]
663 */
664static uint8_t sEmpties[] = {0x83, 0x00, 0x80, 0x84, 0x80, 0x81, 0x00, 0xa0,
665 0xa3, 0x01, 0xa0, 0x02, 0xa0, 0x03, 0x80};
666
Laurence Lundblade02625d42020-06-25 14:41:41 -0700667/* Same as above, but with indefinte lengths */
668static uint8_t sEmptiesIndef[] = {
6690x9F,
Laurence Lundblade2c1faf92020-06-26 22:43:56 -0700670 0x00,
671 0x9F,
672 0xFF,
673 0x9F,
674 0x9F,
675 0xFF,
676 0x9F,
677 0x00,
678 0xFF,
679 0xBF,
680 0xFF,
681 0xBF,
682 0x01,
683 0xBF,
684 0xFF,
685 0x02,
686 0xBF,
687 0xFF,
688 0x03,
689 0x9F,
690 0xFF,
691 0xFF,
692 0xFF,
Laurence Lundblade02625d42020-06-25 14:41:41 -0700693 0xFF};
694
695
696
697static int32_t CheckEmpties(UsefulBufC input, bool bCheckCounts)
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700698{
699 QCBORDecodeContext DCtx;
700 QCBORItem Item;
701
Laurence Lundbladeee851742020-01-08 08:37:05 -0800702 QCBORDecode_Init(&DCtx,
Laurence Lundblade02625d42020-06-25 14:41:41 -0700703 input,
Laurence Lundbladeee851742020-01-08 08:37:05 -0800704 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700705
706 // Array with 3 items
707 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
708 Item.uDataType != QCBOR_TYPE_ARRAY ||
709 Item.uNestingLevel != 0 ||
710 Item.uNextNestLevel != 1 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700711 (bCheckCounts && Item.val.uCount != 3)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700712 return -1;
713 }
714
715 // An integer 0
716 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
717 Item.uDataType != QCBOR_TYPE_INT64 ||
718 Item.uNestingLevel != 1 ||
719 Item.uNextNestLevel != 1 ||
720 Item.val.uint64 != 0) {
721 return -2;
722 }
723
724 // An empty array
725 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
726 Item.uDataType != QCBOR_TYPE_ARRAY ||
727 Item.uNestingLevel != 1 ||
728 Item.uNextNestLevel != 1 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700729 (bCheckCounts && Item.val.uCount != 0)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700730 return -3;
731 }
732
733 // An array with 4 items
734 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
735 Item.uDataType != QCBOR_TYPE_ARRAY ||
736 Item.uNestingLevel != 1 ||
737 Item.uNextNestLevel != 2 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700738 (bCheckCounts && Item.val.uCount != 4)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700739 return -4;
740 }
741
742 // An empty array
743 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
744 Item.uDataType != QCBOR_TYPE_ARRAY ||
745 Item.uNestingLevel != 2 ||
746 Item.uNextNestLevel != 2 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700747 (bCheckCounts && Item.val.uCount != 0)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700748 return -5;
749 }
750
751 // An array with 1 item
752 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
753 Item.uDataType != QCBOR_TYPE_ARRAY ||
754 Item.uNestingLevel != 2 ||
755 Item.uNextNestLevel != 3 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700756 (bCheckCounts && Item.val.uCount != 1)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700757 return -6;
758 }
759
760 // An integer 0
761 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
762 Item.uDataType != QCBOR_TYPE_INT64 ||
763 Item.uNestingLevel != 3 ||
764 Item.uNextNestLevel != 2 ||
765 Item.val.uint64 != 0) {
766 return -7;
767 }
768
769 // An empty map
770 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
771 Item.uDataType != QCBOR_TYPE_MAP ||
772 Item.uNestingLevel != 2 ||
773 Item.uNextNestLevel != 2 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700774 (bCheckCounts && Item.val.uCount != 0)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700775 return -8;
776 }
777
Laurence Lundblade5e87da62020-06-07 03:24:28 -0700778 // A map with 3 items
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700779 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
780 Item.uDataType != QCBOR_TYPE_MAP ||
781 Item.uNestingLevel != 2 ||
782 Item.uNextNestLevel != 3 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700783 (bCheckCounts && Item.val.uCount != 3)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700784 return -9;
785 }
786
787 // An empty map
788 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
789 Item.uDataType != QCBOR_TYPE_MAP ||
790 Item.uNestingLevel != 3 ||
791 Item.uNextNestLevel != 3 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700792 (bCheckCounts && Item.val.uCount != 0)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700793 return -10;
794 }
795
796 // An empty map
797 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
798 Item.uDataType != QCBOR_TYPE_MAP ||
799 Item.uNestingLevel != 3 ||
800 Item.uNextNestLevel != 3 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700801 (bCheckCounts && Item.val.uCount != 0)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700802 return -11;
803 }
804
805 // An empty array
806 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
807 Item.uDataType != QCBOR_TYPE_ARRAY ||
808 Item.uNestingLevel != 3 ||
809 Item.uNextNestLevel != 0 ||
Laurence Lundblade02625d42020-06-25 14:41:41 -0700810 (bCheckCounts && Item.val.uCount != 0)) {
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700811 return -12;
812 }
813
814 if(QCBORDecode_Finish(&DCtx) != QCBOR_SUCCESS) {
815 return -13;
816 }
Laurence Lundblade02625d42020-06-25 14:41:41 -0700817 return 0;
818}
819
820
821int32_t EmptyMapsAndArraysTest()
822{
823 int nResult;
824 nResult = CheckEmpties(UsefulBuf_FROM_BYTE_ARRAY_LITERAL(sEmpties),
825 true);
826 if(nResult) {
827 return nResult;
828 }
829
830 nResult = CheckEmpties(UsefulBuf_FROM_BYTE_ARRAY_LITERAL(sEmptiesIndef),
831 false);
832
833 if(nResult) {
834 return nResult -100;
835 }
Laurence Lundblade9916b1b2019-09-07 22:33:25 -0700836
837 return 0;
838}
839
Laurence Lundblade9e3651c2018-10-10 11:49:55 +0800840
Laurence Lundbladeee851742020-01-08 08:37:05 -0800841static uint8_t spDeepArrays[] = {0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
842 0x81, 0x81, 0x81, 0x80};
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800843
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800844int32_t ParseDeepArrayTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800845{
846 QCBORDecodeContext DCtx;
847 int nReturn = 0;
848 int i;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800849
Laurence Lundbladeee851742020-01-08 08:37:05 -0800850 QCBORDecode_Init(&DCtx,
851 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spDeepArrays),
852 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800853
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800854 for(i = 0; i < 10; i++) {
855 QCBORItem Item;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800856
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800857 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
858 Item.uDataType != QCBOR_TYPE_ARRAY ||
859 Item.uNestingLevel != i) {
860 nReturn = -1;
861 break;
862 }
863 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800864
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800865 return(nReturn);
866}
867
Laurence Lundblade972e59c2018-11-11 15:57:23 +0700868// Big enough to test nesting to the depth of 24
Laurence Lundbladeee851742020-01-08 08:37:05 -0800869static uint8_t spTooDeepArrays[] = {0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
870 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
871 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
872 0x81, 0x81, 0x81, 0x80};
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800873
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800874int32_t ParseTooDeepArrayTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800875{
876 QCBORDecodeContext DCtx;
877 int nReturn = 0;
878 int i;
879 QCBORItem Item;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800880
881
Laurence Lundbladeee851742020-01-08 08:37:05 -0800882 QCBORDecode_Init(&DCtx,
883 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spTooDeepArrays),
884 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800885
Laurence Lundblade972e59c2018-11-11 15:57:23 +0700886 for(i = 0; i < QCBOR_MAX_ARRAY_NESTING1; i++) {
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800887
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800888 if(QCBORDecode_GetNext(&DCtx, &Item) != 0 ||
889 Item.uDataType != QCBOR_TYPE_ARRAY ||
890 Item.uNestingLevel != i) {
891 nReturn = -1;
892 break;
893 }
894 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800895
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800896 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_ARRAY_NESTING_TOO_DEEP)
897 nReturn = -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800898
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800899 return(nReturn);
900}
901
902
903
904
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800905int32_t ShortBufferParseTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800906{
Laurence Lundbladebb1062e2019-08-12 23:28:54 -0700907 int nResult = 0;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800908
Laurence Lundblade06350ea2020-01-27 19:32:40 -0800909 for(size_t nNum = sizeof(spExpectedEncodedInts)-1; nNum; nNum--) {
Laurence Lundbladebb1062e2019-08-12 23:28:54 -0700910 QCBORDecodeContext DCtx;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800911
Laurence Lundbladeee851742020-01-08 08:37:05 -0800912 QCBORDecode_Init(&DCtx,
913 (UsefulBufC){spExpectedEncodedInts, nNum},
914 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800915
Laurence Lundblade06350ea2020-01-27 19:32:40 -0800916 const int nErr = IntegerValuesParseTestInternal(&DCtx);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800917
Laurence Lundbladebb1062e2019-08-12 23:28:54 -0700918 if(nErr != QCBOR_ERR_HIT_END && nErr != QCBOR_ERR_NO_MORE_ITEMS) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800919 nResult = -1;
920 goto Done;
921 }
922 }
923Done:
924 return nResult;
925}
926
927
Laurence Lundblade9e3651c2018-10-10 11:49:55 +0800928
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800929int32_t ShortBufferParseTest2()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800930{
931 uint8_t *pEncoded;
932 int nReturn;
933 size_t nEncodedLen;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800934
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800935 int64_t i1, i2;
936 size_t i3, i4;
937 const uint8_t *s3, *s4;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800938
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800939 nReturn = 0;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800940
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800941 if(CreateSimpleArray(23, 6000, &pEncoded, &nEncodedLen) < 0) {
942 return(-1);
943 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800944
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800945 for(nEncodedLen--; nEncodedLen; nEncodedLen--) {
946 int nResult = ParseOrderedArray(pEncoded, (uint32_t)nEncodedLen, &i1, &i2, &s3, &i3, &s4, &i4);
947 if(nResult == 0) {
948 nReturn = -1;
949 }
950 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800951
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800952 return(nReturn);
953}
954
Laurence Lundbladefab1b522018-10-19 13:40:52 +0530955/*
956 Decode and thoroughly check a moderately complex
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800957 set of maps. Can be run in QCBOR_DECODE_MODE_NORMAL or in
958 QCBOR_DECODE_MODE_MAP_STRINGS_ONLY.
Laurence Lundbladefab1b522018-10-19 13:40:52 +0530959 */
Laurence Lundbladec5fef682020-01-25 11:38:45 -0800960static int32_t ParseMapTest1(QCBORDecodeMode nMode)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800961{
962 QCBORDecodeContext DCtx;
963 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700964 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800965
Laurence Lundbladeee851742020-01-08 08:37:05 -0800966 QCBORDecode_Init(&DCtx,
967 (UsefulBufC){pValidMapEncoded, sizeof(pValidMapEncoded)},
968 nMode);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800969
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900970 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700971 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900972 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800973 if(Item.uDataType != QCBOR_TYPE_MAP ||
974 Item.val.uCount != 3)
975 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800976
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900977 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700978 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900979 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800980 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800981 Item.uDataType != QCBOR_TYPE_INT64 ||
982 Item.val.int64 != 42 ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +0530983 Item.uDataAlloc ||
984 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900985 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("first integer"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800986 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900987 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800988
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900989 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -0700990 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900991 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800992 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +0530993 Item.uDataAlloc ||
994 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +0900995 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("an array of two strings")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +0800996 Item.uDataType != QCBOR_TYPE_ARRAY ||
997 Item.val.uCount != 2)
998 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -0800999
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001000 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001001 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001002 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001003 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301004 Item.uDataAlloc ||
1005 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001006 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("string1"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001007 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001008 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001009
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001010 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001011 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001012 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001013 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301014 Item.uDataAlloc ||
1015 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001016 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("string2"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001017 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001018 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001019
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001020 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001021 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001022 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001023 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301024 Item.uDataAlloc ||
1025 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001026 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("map in a map")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001027 Item.uDataType != QCBOR_TYPE_MAP ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001028 Item.val.uCount != 4) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001029 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001030 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001031
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001032 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001033 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001034 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001035 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001036 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("bytes 1"))||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001037 Item.uDataType != QCBOR_TYPE_BYTE_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301038 Item.uDataAlloc ||
1039 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001040 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("xxxx"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001041 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001042 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001043
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001044 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001045 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001046 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001047 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001048 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("bytes 2")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001049 Item.uDataType != QCBOR_TYPE_BYTE_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301050 Item.uDataAlloc ||
1051 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001052 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("yyyy"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001053 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001054 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001055
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001056 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001057 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001058 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001059 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301060 Item.uDataAlloc ||
1061 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001062 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("another int")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001063 Item.uDataType != QCBOR_TYPE_INT64 ||
1064 Item.val.int64 != 98)
1065 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001066
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001067 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001068 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001069 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001070 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001071 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("text 2"))||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001072 Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301073 Item.uDataAlloc ||
1074 Item.uLabelAlloc ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001075 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("lies, damn lies and statistics"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001076 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001077 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001078
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001079 return 0;
1080}
1081
1082
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001083/*
1084 Decode and thoroughly check a moderately complex
1085 set of maps
1086 */
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001087int32_t ParseMapAsArrayTest()
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001088{
1089 QCBORDecodeContext DCtx;
1090 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001091 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001092
Laurence Lundbladeee851742020-01-08 08:37:05 -08001093 QCBORDecode_Init(&DCtx,
1094 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded),
1095 QCBOR_DECODE_MODE_MAP_AS_ARRAY);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001096
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001097 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001098 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001099 }
Laurence Lundbladed61cbf32018-12-09 11:42:21 -08001100 if(Item.uDataType != QCBOR_TYPE_MAP_AS_ARRAY ||
1101 Item.val.uCount != 6) {
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001102 return -1;
1103 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001104
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001105 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001106 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001107 }
1108 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
1109 Item.uDataAlloc ||
1110 Item.uLabelAlloc ||
1111 Item.uLabelType != QCBOR_TYPE_NONE ||
1112 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("first integer"))) {
1113 return -2;
1114 }
1115
1116 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001117 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001118 }
1119 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1120 Item.uDataType != QCBOR_TYPE_INT64 ||
1121 Item.val.int64 != 42 ||
1122 Item.uDataAlloc ||
1123 Item.uLabelAlloc) {
1124 return -3;
1125 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001126
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001127 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001128 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001129 }
1130 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1131 Item.uDataAlloc ||
1132 Item.uLabelAlloc ||
1133 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("an array of two strings")) ||
1134 Item.uDataType != QCBOR_TYPE_TEXT_STRING) {
1135 return -4;
1136 }
1137
1138 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001139 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001140 }
1141 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1142 Item.uDataAlloc ||
1143 Item.uLabelAlloc ||
1144 Item.uDataType != QCBOR_TYPE_ARRAY ||
1145 Item.val.uCount != 2) {
1146 return -5;
1147 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001148
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001149 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001150 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001151 }
1152 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
1153 Item.val.string.len != 7 ||
1154 Item.uDataAlloc ||
1155 Item.uLabelAlloc ||
1156 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("string1"))) {
1157 return -6;
1158 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001159
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001160 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001161 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001162 }
1163 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
1164 Item.uDataAlloc ||
1165 Item.uLabelAlloc ||
1166 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("string2"))) {
1167 return -7;
1168 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001169
1170
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001171 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001172 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001173 }
1174 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1175 Item.uDataAlloc ||
1176 Item.uLabelAlloc ||
1177 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("map in a map"))) {
1178 return -8;
1179 }
1180
1181 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001182 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001183 }
1184 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1185 Item.uDataAlloc ||
1186 Item.uLabelAlloc ||
Laurence Lundbladed61cbf32018-12-09 11:42:21 -08001187 Item.uDataType != QCBOR_TYPE_MAP_AS_ARRAY ||
1188 Item.val.uCount != 8) {
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001189 return -9;
1190 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001191
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001192 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001193 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001194 }
1195 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1196 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("bytes 1"))||
1197 Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
1198 Item.uDataAlloc ||
1199 Item.uLabelAlloc) {
1200 return -10;
1201 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001202
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001203 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001204 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001205 }
1206 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1207 Item.uDataType != QCBOR_TYPE_BYTE_STRING ||
1208 Item.uDataAlloc ||
1209 Item.uLabelAlloc ||
1210 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("xxxx"))) {
1211 return -11;
1212 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001213
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001214 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001215 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001216 }
1217 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1218 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("bytes 2")) ||
1219 Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
1220 Item.uDataAlloc ||
1221 Item.uLabelAlloc) {
1222 return -12;
1223 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001224
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001225 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001226 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001227 }
1228 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1229 Item.uDataType != QCBOR_TYPE_BYTE_STRING ||
1230 Item.uDataAlloc ||
1231 Item.uLabelAlloc ||
1232 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("yyyy"))) {
1233 return -13;
1234 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001235
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001236 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001237 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001238 }
1239 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1240 Item.uDataAlloc ||
1241 Item.uLabelAlloc ||
1242 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("another int")) ||
1243 Item.uDataType != QCBOR_TYPE_TEXT_STRING) {
1244 return -14;
1245 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001246
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001247 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001248 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001249 }
1250 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1251 Item.uDataAlloc ||
1252 Item.uLabelAlloc ||
1253 Item.uDataType != QCBOR_TYPE_INT64 ||
1254 Item.val.int64 != 98) {
1255 return -15;
1256 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001257
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001258 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001259 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001260 }
1261 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1262 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("text 2"))||
1263 Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
1264 Item.uDataAlloc ||
1265 Item.uLabelAlloc) {
1266 return -16;
1267 }
1268
1269 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001270 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001271 }
1272 if(Item.uLabelType != QCBOR_TYPE_NONE ||
1273 Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
1274 Item.uDataAlloc ||
1275 Item.uLabelAlloc ||
1276 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("lies, damn lies and statistics"))) {
1277 return -17;
1278 }
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001279
1280
1281 /*
1282 Test with map that nearly QCBOR_MAX_ITEMS_IN_ARRAY items in a
1283 map that when interpreted as an array will be too many. Test
1284 data just has the start of the map, not all the items in the map.
1285 */
1286 static const uint8_t pTooLargeMap[] = {0xb9, 0xff, 0xfd};
1287
1288 QCBORDecode_Init(&DCtx,
1289 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pTooLargeMap),
1290 QCBOR_DECODE_MODE_MAP_AS_ARRAY);
1291
1292 if((QCBOR_ERR_ARRAY_TOO_LONG != QCBORDecode_GetNext(&DCtx, &Item))) {
1293 return -50;
1294 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001295
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001296 return 0;
1297}
1298
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001299
1300/*
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301301 Fully or partially decode pValidMapEncoded. When
1302 partially decoding check for the right error code.
1303 How much partial decoding depends on nLevel.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001304
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301305 The partial decodes test error conditions of
1306 incomplete encoded input.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001307
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301308 This could be combined with the above test
1309 and made prettier and maybe a little more
1310 thorough.
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001311 */
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001312static int32_t ExtraBytesTest(int nLevel)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001313{
1314 QCBORDecodeContext DCtx;
1315 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001316 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001317
Laurence Lundbladeee851742020-01-08 08:37:05 -08001318 QCBORDecode_Init(&DCtx,
1319 (UsefulBufC){pValidMapEncoded, sizeof(pValidMapEncoded)},
1320 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001321
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001322 if(nLevel < 1) {
1323 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_EXTRA_BYTES) {
1324 return -1;
1325 } else {
1326 return 0;
1327 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001328 }
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301329
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001330
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001331 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001332 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001333 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001334 if(Item.uDataType != QCBOR_TYPE_MAP ||
1335 Item.val.uCount != 3)
1336 return -1;
1337
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001338 if(nLevel < 2) {
1339 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1340 return -1;
1341 } else {
1342 return 0;
1343 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001344 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001345
1346
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001347 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001348 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001349 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001350 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001351 Item.uDataType != QCBOR_TYPE_INT64 ||
1352 Item.val.uCount != 42 ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001353 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("first integer"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001354 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001355 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001356
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001357 if(nLevel < 3) {
1358 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1359 return -1;
1360 } else {
1361 return 0;
1362 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001363 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001364
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001365 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001366 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001367 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001368 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001369 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("an array of two strings")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001370 Item.uDataType != QCBOR_TYPE_ARRAY ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001371 Item.val.uCount != 2) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001372 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001373 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001374
1375
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001376 if(nLevel < 4) {
1377 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1378 return -1;
1379 } else {
1380 return 0;
1381 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001382 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001383
1384
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001385 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001386 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001387 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001388 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001389 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("string1"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001390 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001391 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001392
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001393 if(nLevel < 5) {
1394 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1395 return -1;
1396 } else {
1397 return 0;
1398 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001399 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001400
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001401 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001402 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001403 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001404 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001405 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("string2"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001406 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001407 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001408
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001409 if(nLevel < 6) {
1410 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1411 return -1;
1412 } else {
1413 return 0;
1414 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001415 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001416
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001417 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001418 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001419 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001420 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001421 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("map in a map")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001422 Item.uDataType != QCBOR_TYPE_MAP ||
1423 Item.val.uCount != 4)
1424 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001425
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001426 if(nLevel < 7) {
1427 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1428 return -1;
1429 } else {
1430 return 0;
1431 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001432 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001433
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001434 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001435 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001436 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001437 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001438 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("bytes 1")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001439 Item.uDataType != QCBOR_TYPE_BYTE_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001440 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("xxxx"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001441 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001442 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001443
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001444 if(nLevel < 8) {
1445 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1446 return -1;
1447 } else {
1448 return 0;
1449 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001450 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001451
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001452 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001453 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001454 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001455 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001456 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("bytes 2")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001457 Item.uDataType != QCBOR_TYPE_BYTE_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001458 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("yyyy"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001459 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001460 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001461
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001462 if(nLevel < 9) {
1463 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1464 return -1;
1465 } else {
1466 return 0;
1467 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001468 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001469
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001470 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001471 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001472 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001473 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001474 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("another int")) ||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001475 Item.uDataType != QCBOR_TYPE_INT64 ||
1476 Item.val.int64 != 98)
1477 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001478
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001479 if(nLevel < 10) {
1480 if(QCBORDecode_Finish(&DCtx) != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
1481 return -1;
1482 } else {
1483 return 0;
1484 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001485 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001486
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001487 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001488 return (int32_t)nCBORError;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001489 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001490 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001491 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("text 2"))||
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001492 Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001493 UsefulBuf_Compare(Item.val.string, UsefulBuf_FromSZ("lies, damn lies and statistics"))) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001494 return -1;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09001495 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001496
Laurence Lundbladefab1b522018-10-19 13:40:52 +05301497 if(QCBORDecode_Finish(&DCtx)) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001498 return -1;
1499 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001500
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001501 return 0;
1502}
1503
1504
1505
Laurence Lundblade844bb5c2020-03-01 17:27:25 -08001506
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001507int32_t ParseMapTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001508{
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001509 // Parse a moderatly complex map structure very thoroughly
1510 int32_t nResult = ParseMapTest1(QCBOR_DECODE_MODE_NORMAL);
1511 if(nResult) {
1512 return nResult;
1513 }
Laurence Lundbladeea567ac2018-12-09 14:03:21 -08001514
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001515 // Again, but in strings-only mode. It should succeed since the input
1516 // map has only string labels.
1517 nResult = ParseMapTest1(QCBOR_DECODE_MODE_MAP_STRINGS_ONLY);
1518 if(nResult) {
1519 return nResult;
1520 }
Laurence Lundbladeea567ac2018-12-09 14:03:21 -08001521
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001522 // Again, but try to finish the decoding before the end of the
1523 // input at 10 different place and see that the right error code
1524 // is returned.
1525 for(int i = 0; i < 10; i++) {
1526 nResult = ExtraBytesTest(i);
1527 if(nResult) {
1528 break;
Laurence Lundblade0fb6c6d2018-10-12 22:02:05 +08001529 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001530 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001531
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001532 return nResult;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001533}
1534
1535
Laurence Lundbladeee851742020-01-08 08:37:05 -08001536static uint8_t spSimpleValues[] = {0x8a, 0xf4, 0xf5, 0xf6, 0xf7, 0xff,
1537 0xe0, 0xf3, 0xf8, 0x00, 0xf8, 0x13,
1538 0xf8, 0x1f, 0xf8, 0x20, 0xf8, 0xff};
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001539
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001540int32_t ParseSimpleTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001541{
1542 QCBORDecodeContext DCtx;
1543 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001544 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001545
1546
Laurence Lundbladeee851742020-01-08 08:37:05 -08001547 QCBORDecode_Init(&DCtx,
1548 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spSimpleValues),
1549 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001550
1551
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001552 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001553 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001554 if(Item.uDataType != QCBOR_TYPE_ARRAY ||
1555 Item.val.uCount != 10)
1556 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001557
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001558 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001559 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001560 if(Item.uDataType != QCBOR_TYPE_FALSE)
1561 return -1;
1562
1563 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001564 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001565 if(Item.uDataType != QCBOR_TYPE_TRUE)
1566 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001567
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001568 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001569 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001570 if(Item.uDataType != QCBOR_TYPE_NULL)
1571 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001572
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001573 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001574 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001575 if(Item.uDataType != QCBOR_TYPE_UNDEF)
1576 return -1;
1577
1578 // A break
Laurence Lundblade9e3651c2018-10-10 11:49:55 +08001579 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_BAD_BREAK)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001580 return -1;
1581
1582 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001583 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001584 if(Item.uDataType != QCBOR_TYPE_UKNOWN_SIMPLE || Item.val.uSimple != 0)
1585 return -1;
1586
1587 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001588 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001589 if(Item.uDataType != QCBOR_TYPE_UKNOWN_SIMPLE || Item.val.uSimple != 19)
1590 return -1;
1591
Laurence Lundblade077475f2019-04-26 09:06:33 -07001592 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_BAD_TYPE_7)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001593 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001594
Laurence Lundblade077475f2019-04-26 09:06:33 -07001595 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_BAD_TYPE_7)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001596 return -1;
1597
Laurence Lundblade077475f2019-04-26 09:06:33 -07001598 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_BAD_TYPE_7)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001599 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001600
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001601 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001602 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001603 if(Item.uDataType != QCBOR_TYPE_UKNOWN_SIMPLE || Item.val.uSimple != 32)
1604 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001605
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001606 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07001607 return (int32_t)nCBORError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001608 if(Item.uDataType != QCBOR_TYPE_UKNOWN_SIMPLE || Item.val.uSimple != 255)
1609 return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001610
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001611 return 0;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001612
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001613}
1614
1615
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001616int32_t NotWellFormedTests()
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001617{
1618 // Loop over all the not-well-formed instance of CBOR
1619 // that are test vectors in not_well_formed_cbor.h
1620 const uint16_t nArraySize = sizeof(paNotWellFormedCBOR)/sizeof(struct someBinaryBytes);
1621 for(uint16_t nIterate = 0; nIterate < nArraySize; nIterate++) {
1622 const struct someBinaryBytes *pBytes = &paNotWellFormedCBOR[nIterate];
1623 const UsefulBufC Input = (UsefulBufC){pBytes->p, pBytes->n};
1624
Laurence Lundbladeee851742020-01-08 08:37:05 -08001625 // Set up decoder context. String allocator needed for indefinite
1626 // string test cases
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001627 QCBORDecodeContext DCtx;
1628 QCBORDecode_Init(&DCtx, Input, QCBOR_DECODE_MODE_NORMAL);
1629 UsefulBuf_MAKE_STACK_UB(Pool, 100);
1630 QCBORDecode_SetMemPool(&DCtx, Pool, 0);
1631
1632 // Loop getting items until no more to get
Laurence Lundbladef71e1622020-08-06 18:52:13 -07001633 QCBORError uCBORError;
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001634 do {
1635 QCBORItem Item;
1636
Laurence Lundbladef71e1622020-08-06 18:52:13 -07001637 uCBORError = QCBORDecode_GetNext(&DCtx, &Item);
1638 } while(uCBORError == QCBOR_SUCCESS);
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001639
1640 // Every test vector must fail with
1641 // a not-well-formed error. If not
1642 // this test fails.
Laurence Lundbladef71e1622020-08-06 18:52:13 -07001643 if(!QCBORDecode_IsNotWellFormed(uCBORError) &&
1644 uCBORError != QCBOR_ERR_NO_MORE_ITEMS) {
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001645 // Return index of failure in the error code
1646 return 2000 + nIterate;
1647 }
1648 }
1649 return 0;
1650}
1651
1652
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001653struct FailInput {
Laurence Lundblade59289e52019-12-30 13:44:37 -08001654 UsefulBufC Input;
1655 QCBORError nError;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001656};
1657
Laurence Lundblade59289e52019-12-30 13:44:37 -08001658
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001659static int32_t ProcessFailures(struct FailInput *pFailInputs, size_t nNumFails)
Laurence Lundblade59289e52019-12-30 13:44:37 -08001660{
1661 for(struct FailInput *pF = pFailInputs; pF < pFailInputs + nNumFails; pF++) {
1662 // Set up the decoding context including a memory pool so that
1663 // indefinite length items can be checked
1664 QCBORDecodeContext DCtx;
1665 QCBORDecode_Init(&DCtx, pF->Input, QCBOR_DECODE_MODE_NORMAL);
1666 UsefulBuf_MAKE_STACK_UB(Pool, 100);
Laurence Lundblade830fbf92020-05-31 17:22:33 -07001667
Laurence Lundblade59289e52019-12-30 13:44:37 -08001668 QCBORError nCBORError = QCBORDecode_SetMemPool(&DCtx, Pool, 0);
1669 if(nCBORError) {
1670 return -9;
1671 }
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001672
Laurence Lundblade59289e52019-12-30 13:44:37 -08001673 // Iterate until there is an error of some sort error
1674 QCBORItem Item;
1675 do {
Laurence Lundblade02625d42020-06-25 14:41:41 -07001676 // Set to something none-zero, something other than QCBOR_TYPE_NONE
Laurence Lundblade59289e52019-12-30 13:44:37 -08001677 memset(&Item, 0x33, sizeof(Item));
1678
1679 nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
1680 } while(nCBORError == QCBOR_SUCCESS);
1681
1682 // Must get the expected error or the this test fails
1683 // The data and label type must also be QCBOR_TYPE_NONE
1684 if(nCBORError != pF->nError ||
1685 Item.uDataType != QCBOR_TYPE_NONE ||
1686 Item.uLabelType != QCBOR_TYPE_NONE) {
Laurence Lundblade06350ea2020-01-27 19:32:40 -08001687 // return index of CBOR + 100
Laurence Lundblade830fbf92020-05-31 17:22:33 -07001688 const size_t nIndex = (size_t)(pF - pFailInputs);
Laurence Lundblade06350ea2020-01-27 19:32:40 -08001689 return (int32_t)(nIndex * 100 + nCBORError);
Laurence Lundblade59289e52019-12-30 13:44:37 -08001690 }
1691 }
1692
1693 return 0;
1694}
1695
1696
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001697struct FailInput Failures[] = {
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001698 // Most of this is copied from not_well_formed.h. Here the error code
1699 // returned is also checked.
1700
1701 // Indefinite length strings must be closed off
1702 // An indefinite length byte string not closed off
1703 { {(uint8_t[]){0x5f, 0x41, 0x00}, 3}, QCBOR_ERR_HIT_END },
1704 // An indefinite length text string not closed off
1705 { {(uint8_t[]){0x7f, 0x61, 0x00}, 3}, QCBOR_ERR_HIT_END },
1706
1707
1708 // All the chunks in an indefinite length string must be of the type of indefinite length string
1709 // indefinite length byte string with text string chunk
1710 { {(uint8_t[]){0x5f, 0x61, 0x00, 0xff}, 4}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1711 // indefinite length text string with a byte string chunk
1712 { {(uint8_t[]){0x7f, 0x41, 0x00, 0xff}, 4}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1713 // indefinite length byte string with an positive integer chunk
1714 { {(uint8_t[]){0x5f, 0x00, 0xff}, 3}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1715 // indefinite length byte string with an negative integer chunk
1716 { {(uint8_t[]){0x5f, 0x21, 0xff}, 3}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1717 // indefinite length byte string with an array chunk
1718 { {(uint8_t[]){0x5f, 0x80, 0xff}, 3}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1719 // indefinite length byte string with an map chunk
1720 { {(uint8_t[]){0x5f, 0xa0, 0xff}, 3}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1721 // indefinite length byte string with tagged integer chunk
1722 { {(uint8_t[]){0x5f, 0xc0, 0x00, 0xff}, 4}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1723 // indefinite length byte string with an simple type chunk
1724 { {(uint8_t[]){0x5f, 0xe0, 0xff}, 3}, QCBOR_ERR_INDEFINITE_STRING_CHUNK },
1725 { {(uint8_t[]){0x5f, 0x5f, 0x41, 0x00, 0xff, 0xff}, 6}, QCBOR_ERR_INDEFINITE_STRING_CHUNK},
1726 // indefinite length text string with indefinite string inside
1727 { {(uint8_t[]){0x7f, 0x7f, 0x61, 0x00, 0xff, 0xff}, 6}, QCBOR_ERR_INDEFINITE_STRING_CHUNK},
1728
1729
1730 // Definte length maps and arrays must be closed by having the right number of items
1731 // A definte length array that is supposed to have 1 item, but has none
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001732 { {(uint8_t[]){0x81}, 1}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001733 // A definte length array that is supposed to have 2 items, but has only 1
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001734 { {(uint8_t[]){0x82, 0x00}, 2}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001735 // A definte length array that is supposed to have 511 items, but has only 1
1736 { {(uint8_t[]){0x9a, 0x01, 0xff, 0x00}, 4}, QCBOR_ERR_HIT_END },
1737 // A definte length map that is supposed to have 1 item, but has none
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001738 { {(uint8_t[]){0xa1}, 1}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001739 // A definte length map that is supposed to have s item, but has only 1
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001740 { {(uint8_t[]){0xa2, 0x01, 0x02}, 3}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001741
1742
1743 // Indefinte length maps and arrays must be ended by a break
1744 // Indefinite length array with zero items and no break
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001745 { {(uint8_t[]){0x9f}, 1}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001746 // Indefinite length array with two items and no break
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001747 { {(uint8_t[]){0x9f, 0x01, 0x02}, 3}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001748 // Indefinite length map with zero items and no break
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001749 { {(uint8_t[]){0xbf}, 1}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001750 // Indefinite length map with two items and no break
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001751 { {(uint8_t[]){0xbf, 0x01, 0x02, 0x01, 0x02}, 5}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001752
1753
1754 // Nested maps and arrays must be closed off (some extra nested test vectors)
Laurence Lundblade642282a2020-06-23 12:00:33 -07001755 // Unclosed indefinite array containing a closed definite length array
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001756 { {(uint8_t[]){0x9f, 0x80, 0x00}, 3}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundblade642282a2020-06-23 12:00:33 -07001757 // Definite length array containing an unclosed indefinite length array
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001758 { {(uint8_t[]){0x81, 0x9f}, 2}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001759 // Deeply nested definite length arrays with deepest one unclosed
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001760 { {(uint8_t[]){0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81}, 9}, QCBOR_ERR_NO_MORE_ITEMS }, // TODO: 23
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001761 // Deeply nested indefinite length arrays with deepest one unclosed
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001762 { {(uint8_t[]){0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0xff, 0xff, 0xff, 0xff}, 9}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001763 // Mixed nesting with indefinite unclosed
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001764 { {(uint8_t[]){0x9f, 0x81, 0x9f, 0x81, 0x9f, 0x9f, 0xff, 0xff, 0xff}, 9}, QCBOR_ERR_NO_MORE_ITEMS },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001765 // Mixed nesting with definite unclosed
Laurence Lundbladeee851742020-01-08 08:37:05 -08001766 { {(uint8_t[]){0x9f, 0x82, 0x9f, 0x81, 0x9f, 0x9f, 0xff, 0xff, 0xff, 0xff}, 10}, QCBOR_ERR_BAD_BREAK },
Laurence Lundblade0a042a92020-06-12 14:09:50 -07001767 // TODO: a few more definite indefinite length combos and check with CBORbis.
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001768
1769
1770 // The "argument" for the data item is incomplete
1771 // Positive integer missing 1 byte argument
1772 { {(uint8_t[]){0x18}, 1}, QCBOR_ERR_HIT_END },
1773 // Positive integer missing 2 byte argument
1774 { {(uint8_t[]){0x19}, 1}, QCBOR_ERR_HIT_END },
1775 // Positive integer missing 4 byte argument
1776 { {(uint8_t[]){0x1a}, 1}, QCBOR_ERR_HIT_END },
1777 // Positive integer missing 8 byte argument
1778 { {(uint8_t[]){0x1b}, 1}, QCBOR_ERR_HIT_END },
1779 // Positive integer missing 1 byte of 2 byte argument
1780 { {(uint8_t[]){0x19, 0x01}, 2}, QCBOR_ERR_HIT_END },
1781 // Positive integer missing 2 bytes of 4 byte argument
1782 { {(uint8_t[]){0x1a, 0x01, 0x02}, 3}, QCBOR_ERR_HIT_END },
1783 // Positive integer missing 1 bytes of 7 byte argument
1784 { {(uint8_t[]){0x1b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}, 8}, QCBOR_ERR_HIT_END },
1785 // Negative integer missing 1 byte argument
1786 { {(uint8_t[]){0x38}, 1}, QCBOR_ERR_HIT_END },
1787 // Binary string missing 1 byte argument
1788 { {(uint8_t[]){0x58}, 1}, QCBOR_ERR_HIT_END },
1789 // Text string missing 1 byte argument
1790 { {(uint8_t[]){0x78}, 1}, QCBOR_ERR_HIT_END },
1791 // Array missing 1 byte argument
1792 { {(uint8_t[]){0x98}, 1}, QCBOR_ERR_HIT_END },
1793 // Map missing 1 byte argument
1794 { {(uint8_t[]){0xb8}, 1}, QCBOR_ERR_HIT_END },
1795 // Tag missing 1 byte argument
1796 { {(uint8_t[]){0xd8}, 1}, QCBOR_ERR_HIT_END },
1797 // Simple missing 1 byte argument
1798 { {(uint8_t[]){0xf8}, 1}, QCBOR_ERR_HIT_END },
1799
1800
1801 // Breaks must not occur in definite length arrays and maps
1802 // Array of length 1 with sole member replaced by a break
1803 { {(uint8_t[]){0x81, 0xff}, 2}, QCBOR_ERR_BAD_BREAK },
1804 // Array of length 2 with 2nd member replaced by a break
1805 { {(uint8_t[]){0x82, 0x00, 0xff}, 3}, QCBOR_ERR_BAD_BREAK },
1806 // Map of length 1 with sole member label replaced by a break
1807 { {(uint8_t[]){0xa1, 0xff}, 2}, QCBOR_ERR_BAD_BREAK },
1808 // Map of length 1 with sole member label replaced by break
1809 // Alternate representation that some decoders handle difference
1810 { {(uint8_t[]){0xa1, 0xff, 0x00}, 3}, QCBOR_ERR_BAD_BREAK },
1811 // Array of length 1 with 2nd member value replaced by a break
1812 { {(uint8_t[]){0xa1, 0x00, 0xff}, 3}, QCBOR_ERR_BAD_BREAK },
1813 // Map of length 2 with 2nd member replaced by a break
1814 { {(uint8_t[]){0xa2, 0x00, 0x00, 0xff}, 4}, QCBOR_ERR_BAD_BREAK },
1815
1816
1817 // Breaks must not occur on their own out of an indefinite length data item
1818 // A bare break is not well formed
1819 { {(uint8_t[]){0xff}, 1}, QCBOR_ERR_BAD_BREAK },
1820 // A bare break after a zero length definite length array
1821 { {(uint8_t[]){0x80, 0xff}, 2}, QCBOR_ERR_BAD_BREAK },
1822 // A bare break after a zero length indefinite length map
1823 { {(uint8_t[]){0x9f, 0xff, 0xff}, 3}, QCBOR_ERR_BAD_BREAK },
1824
1825
1826 // Forbidden two byte encodings of simple types
1827 // Must use 0xe0 instead
1828 { {(uint8_t[]){0xf8, 0x00}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1829 // Should use 0xe1 instead
1830 { {(uint8_t[]){0xf8, 0x01}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1831 // Should use 0xe2 instead
1832 { {(uint8_t[]){0xf8, 0x02}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1833 // Should use 0xe3 instead
1834 { {(uint8_t[]){0xf8, 0x03}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1835 // Should use 0xe4 instead
1836 { {(uint8_t[]){0xf8, 0x04}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1837 // Should use 0xe5 instead
1838 { {(uint8_t[]){0xf8, 0x05}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1839 // Should use 0xe6 instead
1840 { {(uint8_t[]){0xf8, 0x06}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1841 // Should use 0xe7 instead
1842 { {(uint8_t[]){0xf8, 0x07}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1843 // Should use 0xe8 instead
1844 { {(uint8_t[]){0xf8, 0x08}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1845 // Should use 0xe9 instead
1846 { {(uint8_t[]){0xf8, 0x09}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1847 // Should use 0xea instead
1848 { {(uint8_t[]){0xf8, 0x0a}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1849 // Should use 0xeb instead
1850 { {(uint8_t[]){0xf8, 0x0b}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1851 // Should use 0xec instead
1852 { {(uint8_t[]){0xf8, 0x0c}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1853 // Should use 0xed instead
1854 { {(uint8_t[]){0xf8, 0x0d}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1855 // Should use 0xee instead
1856 { {(uint8_t[]){0xf8, 0x0e}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1857 // Should use 0xef instead
1858 { {(uint8_t[]){0xf8, 0x0f}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1859 // Should use 0xf0 instead
1860 { {(uint8_t[]){0xf8, 0x10}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1861 // Should use 0xf1 instead
1862 { {(uint8_t[]){0xf8, 0x11}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1863 // Should use 0xf2 instead
1864 { {(uint8_t[]){0xf8, 0x12}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1865 // Must use 0xf3 instead
1866 { {(uint8_t[]){0xf8, 0x13}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1867 // Must use 0xf4 instead
1868 { {(uint8_t[]){0xf8, 0x14}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1869 // Must use 0xf5 instead
1870 { {(uint8_t[]){0xf8, 0x15}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1871 // Must use 0xf6 instead
1872 { {(uint8_t[]){0xf8, 0x16}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1873 // Must use 0xf7 instead
1874 { {(uint8_t[]){0xf8, 0x17}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1875 // Must use 0xf8 instead
1876 { {(uint8_t[]){0xf8, 0x18}, 2}, QCBOR_ERR_BAD_TYPE_7 },
1877
1878
1879 // Integers with additional info indefinite length
1880 // Positive integer with additional info indefinite length
1881 { {(uint8_t[]){0x1f}, 1}, QCBOR_ERR_BAD_INT },
1882 // Negative integer with additional info indefinite length
1883 { {(uint8_t[]){0x3f}, 1}, QCBOR_ERR_BAD_INT },
1884 // CBOR tag with "argument" an indefinite length
1885 { {(uint8_t[]){0xdf, 0x00}, 2}, QCBOR_ERR_BAD_INT },
1886 // CBOR tag with "argument" an indefinite length alternate vector
1887 { {(uint8_t[]){0xdf}, 1}, QCBOR_ERR_BAD_INT },
1888
1889
1890 // Missing bytes from a deterministic length string
1891 // A byte string is of length 1 without the 1 byte
1892 { {(uint8_t[]){0x41}, 1}, QCBOR_ERR_HIT_END },
1893 // A text string is of length 1 without the 1 byte
1894 { {(uint8_t[]){0x61}, 1}, QCBOR_ERR_HIT_END },
Laurence Lundblade42272e42020-01-31 07:50:53 -08001895 // Byte string should have 2^32-15 bytes, but has one
1896 { {(uint8_t[]){0x5a, 0xff, 0xff, 0xff, 0xf0, 0x00}, 6}, QCBOR_ERR_HIT_END },
1897 // Byte string should have 2^32-15 bytes, but has one
1898 { {(uint8_t[]){0x7a, 0xff, 0xff, 0xff, 0xf0, 0x00}, 6}, QCBOR_ERR_HIT_END },
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001899
1900
1901 // Use of unassigned additional information values
1902 // Major type positive integer with reserved value 28
1903 { {(uint8_t[]){0x1c}, 1}, QCBOR_ERR_UNSUPPORTED },
1904 // Major type positive integer with reserved value 29
1905 { {(uint8_t[]){0x1d}, 1}, QCBOR_ERR_UNSUPPORTED },
1906 // Major type positive integer with reserved value 30
1907 { {(uint8_t[]){0x1e}, 1}, QCBOR_ERR_UNSUPPORTED },
1908 // Major type negative integer with reserved value 28
1909 { {(uint8_t[]){0x3c}, 1}, QCBOR_ERR_UNSUPPORTED },
1910 // Major type negative integer with reserved value 29
1911 { {(uint8_t[]){0x3d}, 1}, QCBOR_ERR_UNSUPPORTED },
1912 // Major type negative integer with reserved value 30
1913 { {(uint8_t[]){0x3e}, 1}, QCBOR_ERR_UNSUPPORTED },
1914 // Major type byte string with reserved value 28 length
1915 { {(uint8_t[]){0x5c}, 1}, QCBOR_ERR_UNSUPPORTED },
1916 // Major type byte string with reserved value 29 length
1917 { {(uint8_t[]){0x5d}, 1}, QCBOR_ERR_UNSUPPORTED },
1918 // Major type byte string with reserved value 30 length
1919 { {(uint8_t[]){0x5e}, 1}, QCBOR_ERR_UNSUPPORTED },
1920 // Major type text string with reserved value 28 length
1921 { {(uint8_t[]){0x7c}, 1}, QCBOR_ERR_UNSUPPORTED },
1922 // Major type text string with reserved value 29 length
1923 { {(uint8_t[]){0x7d}, 1}, QCBOR_ERR_UNSUPPORTED },
1924 // Major type text string with reserved value 30 length
1925 { {(uint8_t[]){0x7e}, 1}, QCBOR_ERR_UNSUPPORTED },
1926 // Major type array with reserved value 28 length
1927 { {(uint8_t[]){0x9c}, 1}, QCBOR_ERR_UNSUPPORTED },
1928 // Major type array with reserved value 29 length
1929 { {(uint8_t[]){0x9d}, 1}, QCBOR_ERR_UNSUPPORTED },
1930 // Major type array with reserved value 30 length
1931 { {(uint8_t[]){0x9e}, 1}, QCBOR_ERR_UNSUPPORTED },
1932 // Major type map with reserved value 28 length
1933 { {(uint8_t[]){0xbc}, 1}, QCBOR_ERR_UNSUPPORTED },
1934 // Major type map with reserved value 29 length
1935 { {(uint8_t[]){0xbd}, 1}, QCBOR_ERR_UNSUPPORTED },
1936 // Major type map with reserved value 30 length
1937 { {(uint8_t[]){0xbe}, 1}, QCBOR_ERR_UNSUPPORTED },
1938 // Major type tag with reserved value 28 length
1939 { {(uint8_t[]){0xdc}, 1}, QCBOR_ERR_UNSUPPORTED },
1940 // Major type tag with reserved value 29 length
1941 { {(uint8_t[]){0xdd}, 1}, QCBOR_ERR_UNSUPPORTED },
1942 // Major type tag with reserved value 30 length
1943 { {(uint8_t[]){0xde}, 1}, QCBOR_ERR_UNSUPPORTED },
1944 // Major type simple with reserved value 28 length
1945 { {(uint8_t[]){0xfc}, 1}, QCBOR_ERR_UNSUPPORTED },
1946 // Major type simple with reserved value 29 length
1947 { {(uint8_t[]){0xfd}, 1}, QCBOR_ERR_UNSUPPORTED },
1948 // Major type simple with reserved value 30 length
1949 { {(uint8_t[]){0xfe}, 1}, QCBOR_ERR_UNSUPPORTED },
1950
1951
1952 // Maps must have an even number of data items (key & value)
1953 // Map with 1 item when it should have 2
1954 { {(uint8_t[]){0xa1, 0x00}, 2}, QCBOR_ERR_HIT_END },
1955 // Map with 3 item when it should have 4
1956 { {(uint8_t[]){0xa2, 0x00, 0x00, 0x00}, 2}, QCBOR_ERR_HIT_END },
1957 // Map with 1 item when it should have 2
1958 { {(uint8_t[]){0xbf, 0x00, 0xff}, 3}, QCBOR_ERR_BAD_BREAK },
1959 // Map with 3 item when it should have 4
1960 { {(uint8_t[]){0xbf, 0x00, 0x00, 0x00, 0xff}, 5}, QCBOR_ERR_BAD_BREAK },
1961
1962
1963 // In addition to not-well-formed, some invalid CBOR
Laurence Lundbladeee851742020-01-08 08:37:05 -08001964 // Text-based date, with an integer
1965 { {(uint8_t[]){0xc0, 0x00}, 2}, QCBOR_ERR_BAD_OPT_TAG },
1966 // Epoch date, with an byte string
1967 { {(uint8_t[]){0xc1, 0x41, 0x33}, 3}, QCBOR_ERR_BAD_OPT_TAG },
1968 // tagged as both epoch and string dates
1969 { {(uint8_t[]){0xc1, 0xc0, 0x00}, 3}, QCBOR_ERR_BAD_OPT_TAG },
1970 // big num tagged an int, not a byte string
1971 { {(uint8_t[]){0xc2, 0x00}, 2}, QCBOR_ERR_BAD_OPT_TAG },
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001972};
1973
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001974int32_t DecodeFailureTests()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001975{
Laurence Lundbladec5fef682020-01-25 11:38:45 -08001976 int32_t nResult;
Laurence Lundbladebb1062e2019-08-12 23:28:54 -07001977
Laurence Lundblade59289e52019-12-30 13:44:37 -08001978 nResult = ProcessFailures(Failures, sizeof(Failures)/sizeof(struct FailInput));
1979 if(nResult) {
1980 return nResult;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001981 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001982
Laurence Lundblade3a6042e2019-06-28 19:58:04 -07001983 // Corrupt the UsefulInputBuf and see that
1984 // it reflected correctly for CBOR decoding
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001985 QCBORDecodeContext DCtx;
1986 QCBORItem Item;
1987 QCBORError uQCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08001988
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001989 QCBORDecode_Init(&DCtx,
1990 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spSimpleValues),
1991 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08001992
Laurence Lundbladee6f15112020-07-23 18:44:16 -07001993 if((uQCBORError = QCBORDecode_GetNext(&DCtx, &Item))) {
1994 return (int32_t)uQCBORError;
1995 }
1996 if(Item.uDataType != QCBOR_TYPE_ARRAY || Item.val.uCount != 10) {
1997 // This wasn't supposed to happen
1998 return -1;
1999 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002000
Laurence Lundbladee6f15112020-07-23 18:44:16 -07002001 DCtx.InBuf.magic = 0; // Reach in and corrupt the UsefulInputBuf
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002002
Laurence Lundbladee6f15112020-07-23 18:44:16 -07002003 uQCBORError = QCBORDecode_GetNext(&DCtx, &Item);
2004 if(uQCBORError != QCBOR_ERR_NO_MORE_ITEMS) {
2005 // Did not get back the error expected
2006 return -2;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002007 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002008
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002009/*
Laurence Lundbladee6f15112020-07-23 18:44:16 -07002010 TODO: fix this
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002011 This test is disabled until QCBOREncode_EncodeHead() is brought in so
2012 the size encoded can be tied to SIZE_MAX and work for all size CPUs.
2013
2014 This relies on the largest string allowed being SIZE_MAX -4 rather than
2015 SIZE_MAX. That way the test can be performed.
2016 {
2017 QCBORDecodeContext DCtx;
2018 QCBORItem Item;
2019
2020 static uint8_t foo[] = {0x5b, 0xff, 0xff, 0xff, 0xff,
2021 0xff, 0xff, 0xff, 0xff};
2022
2023 QCBORDecode_Init(&DCtx,
2024 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(foo),
2025 QCBOR_DECODE_MODE_NORMAL);
2026
2027 if(QCBOR_ERR_STRING_TOO_LONG != QCBORDecode_GetNext(&DCtx, &Item)) {
2028 return -4;
2029 }
2030 }
2031*/
2032
Laurence Lundblade3a6042e2019-06-28 19:58:04 -07002033 return 0;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002034}
2035
2036
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002037/* Try all 256 values of the byte at nLen including recursing for
2038 each of the values to try values at nLen+1 ... up to nLenMax
2039 */
Laurence Lundblade06350ea2020-01-27 19:32:40 -08002040static void ComprehensiveInputRecurser(uint8_t *pBuf, size_t nLen, size_t nLenMax)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002041{
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002042 if(nLen >= nLenMax) {
2043 return;
2044 }
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -08002045
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002046 for(int inputByte = 0; inputByte < 256; inputByte++) {
2047 // Set up the input
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002048 pBuf[nLen] = (uint8_t)inputByte;
Laurence Lundblade25c6c0a2018-12-17 13:21:59 -08002049 const UsefulBufC Input = {pBuf, nLen+1};
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -08002050
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002051 // Get ready to parse
2052 QCBORDecodeContext DCtx;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002053 QCBORDecode_Init(&DCtx, Input, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002054
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002055 // Parse by getting the next item until an error occurs
2056 // Just about every possible decoder error can occur here
2057 // The goal of this test is not to check for the correct
2058 // error since that is not really possible. It is to
2059 // see that there is no crash on hostile input.
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002060 while(1) {
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002061 QCBORItem Item;
2062 QCBORError nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002063 if(nCBORError != QCBOR_SUCCESS) {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002064 break;
2065 }
2066 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002067
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002068 ComprehensiveInputRecurser(pBuf, nLen+1, nLenMax);
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002069 }
2070}
2071
2072
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002073int32_t ComprehensiveInputTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002074{
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002075 // Size 2 tests 64K inputs and runs quickly
2076 uint8_t pBuf[2];
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002077
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002078 ComprehensiveInputRecurser(pBuf, 0, sizeof(pBuf));
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002079
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002080 return 0;
2081}
2082
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002083
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002084int32_t BigComprehensiveInputTest()
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002085{
2086 // size 3 tests 16 million inputs and runs OK
2087 // in seconds on fast machines. Size 4 takes
2088 // 10+ minutes and 5 half a day on fast
2089 // machines. This test is kept separate from
2090 // the others so as to no slow down the use
2091 // of them as a very frequent regression.
2092 uint8_t pBuf[3]; //
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -08002093
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002094 ComprehensiveInputRecurser(pBuf, 0, sizeof(pBuf));
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -08002095
Laurence Lundbladea2e29072018-12-30 09:20:06 -08002096 return 0;
2097}
2098
2099
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002100static uint8_t spDateTestInput[] = {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002101 0xc0, // tag for string date
2102 0x6a, '1','9','8','5','-','0','4','-','1','2', // Date string
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002103
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002104 0xc1, // tag for epoch date
2105 0x1a, 0x53, 0x72, 0x4E, 0x00, // Epoch date 1400000000; Tue, 13 May 2014 16:53:20 GMT
2106
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002107 // CBOR_TAG_B64
2108 0xc1, 0xcf, 0xd8, 0x22, // 0xee, // Epoch date with extra tags TODO: fix this test
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002109 0x1a, 0x53, 0x72, 0x4E, 0x01,
2110
2111 0xc1, // tag for epoch date
2112 0x1b, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // Too large integer
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002113
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002114 0xc1, // tag for epoch date
2115 0xfa, 0x3f, 0x8c, 0xcc, 0xcd, // double with value 1.1
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002116
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002117 0xc1, // tag for epoch date
Laurence Lundbladea1ad8782019-11-08 00:12:11 -08002118 0xfa, 0x7f, 0x7f, 0xff, 0xff, // 3.4028234663852886e+38 too large
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002119
Laurence Lundbladea1ad8782019-11-08 00:12:11 -08002120 0xc1, // tag for epoch date
2121 0xfb, 0x43, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 9223372036854775808.000000 just barely too large
2122 //0xfa, 0x7f, 0x7f, 0xff, 0xff // 3.4028234663852886e+38 too large
2123
2124 0xc1, // tag for epoch date
2125 0xfb, 0x43, 0xdf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe // 9223372036854773760 largest supported
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002126};
2127
2128
2129// have to check float expected only to within an epsilon
2130int CHECK_EXPECTED_DOUBLE(double val, double expected) {
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002131
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002132 double diff = val - expected;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002133
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002134 diff = fabs(diff);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002135
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002136 return diff > 0.0000001;
2137}
2138
2139
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002140int32_t DateParseTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002141{
2142 QCBORDecodeContext DCtx;
2143 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07002144 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002145
Laurence Lundbladeee851742020-01-08 08:37:05 -08002146 QCBORDecode_Init(&DCtx,
2147 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spDateTestInput),
2148 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002149
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002150 const uint64_t uTags[] = {15};
2151 QCBORTagListIn TagList = {1, uTags};
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002152
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002153 QCBORDecode_SetCallerConfiguredTagList(&DCtx, &TagList);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002154
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002155 // String date
2156 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
2157 return -1;
2158 if(Item.uDataType != QCBOR_TYPE_DATE_STRING ||
Laurence Lundblade9e3651c2018-10-10 11:49:55 +08002159 UsefulBuf_Compare(Item.val.dateString, UsefulBuf_FromSZ("1985-04-12"))){
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002160 return -2;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002161 }
2162
2163 // Epoch date
2164 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002165 return -3;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002166 if(Item.uDataType != QCBOR_TYPE_DATE_EPOCH ||
2167 Item.val.epochDate.nSeconds != 1400000000 ||
2168 Item.val.epochDate.fSecondsFraction != 0 ) {
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002169 return -4;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002170 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002171
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002172 // Epoch date with extra CBOR_TAG_B64 tag that doesn't really mean anything
2173 // but want to be sure extra tag doesn't cause a problem
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002174 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002175 return -5;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002176 if(Item.uDataType != QCBOR_TYPE_DATE_EPOCH ||
2177 Item.val.epochDate.nSeconds != 1400000001 ||
2178 Item.val.epochDate.fSecondsFraction != 0 ||
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002179 !QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_B64)) {
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002180 return -6;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002181 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002182
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002183 // Epoch date that is too large for our representation
2184 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_DATE_OVERFLOW) {
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002185 return -7;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002186 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002187
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002188 // Epoch date in float format with fractional seconds
2189 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002190 return -8;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002191 if(Item.uDataType != QCBOR_TYPE_DATE_EPOCH ||
2192 Item.val.epochDate.nSeconds != 1 ||
2193 CHECK_EXPECTED_DOUBLE(Item.val.epochDate.fSecondsFraction, 0.1 )) {
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002194 return -9;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002195 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002196
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002197 // Epoch date float that is too large for our representation
2198 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_DATE_OVERFLOW) {
Laurence Lundblade67bd5512018-11-02 21:44:06 +07002199 return -10;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002200 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002201
Laurence Lundbladea1ad8782019-11-08 00:12:11 -08002202 // Epoch date double that is just slightly too large
2203 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_ERR_DATE_OVERFLOW) {
2204 return -11;
2205 }
2206
2207 // Largest double epoch date supported
2208 if(QCBORDecode_GetNext(&DCtx, &Item) != QCBOR_SUCCESS ||
2209 Item.uDataType != QCBOR_TYPE_DATE_EPOCH ||
2210 Item.val.epochDate.nSeconds != 9223372036854773760 ||
2211 Item.val.epochDate.nSeconds == 0) {
2212 return -12;
2213 }
Laurence Lundbladeee851742020-01-08 08:37:05 -08002214 // TODO: could use a few more tests with float, double, and half precsion
2215 // and negative (but coverage is still pretty good)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002216
2217 return 0;
2218}
2219
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002220// Really simple basic input for tagging test
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002221static uint8_t spOptTestInput[] = {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002222 0xd9, 0xd9, 0xf7, // CBOR magic number
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002223 0x81, // Array of one
2224 0xd8, 0x04, // non-preferred serialization of tag 4
2225 0x82, 0x01, 0x03}; // fraction 1/3
2226
Laurence Lundblade59289e52019-12-30 13:44:37 -08002227/*
2228 DB 9192939495969798 # tag(10489608748473423768)
2229 80 # array(0)
2230 */
Laurence Lundbladeee851742020-01-08 08:37:05 -08002231static uint8_t spEncodedLargeTag[] = {0xdb, 0x91, 0x92, 0x93, 0x94, 0x95,
2232 0x96, 0x97, 0x98, 0x80};
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002233
Laurence Lundblade59289e52019-12-30 13:44:37 -08002234/*
2235DB 9192939495969798 # tag(10489608748473423768)
2236 D8 88 # tag(136)
2237 C6 # tag(6)
2238 C7 # tag(7)
2239 80 # array(0)
2240*/
Laurence Lundbladeee851742020-01-08 08:37:05 -08002241static uint8_t spLotsOfTags[] = {0xdb, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
2242 0x97, 0x98, 0xd8, 0x88, 0xc6, 0xc7, 0x80};
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002243
2244/*
2245 The cbor.me parse of this.
2246 55799(55799(55799({6(7(-23)): 5859837686836516696(7({7(-20): 11({17(-18): 17(17(17("Organization"))),
Laurence Lundblade59289e52019-12-30 13:44:37 -08002247 9(-17): 773("SSG"), -15: 16(17(6(7(8(9(10(11(12(13(14(15("Confusion")))))))))))), 17(-16): 17("San Diego"),
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002248 17(-14): 17("US")}), 23(-19): 19({-11: 9({-9: -7}),
2249 90599561(90599561(90599561(-10))): 12(h'0102030405060708090A')})})),
2250 16(-22): 23({11(8(7(-5))): 8(-3)})})))
2251 */
2252static uint8_t spCSRWithTags[] = {
2253 0xd9, 0xd9, 0xf7, 0xd9, 0xd9, 0xf7, 0xd9, 0xd9, 0xf7, 0xa2,
2254 0xc6, 0xc7, 0x36,
2255 0xdb, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0xc7, 0xa2,
2256 0xda, 0x00, 0x00, 0x00, 0x07, 0x33,
2257 0xcb, 0xa5,
2258 0xd1, 0x31,
2259 0xd1, 0xd1, 0xd1, 0x6c,
2260 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e,
2261 0xc9, 0x30,
2262 0xd9, 0x03, 0x05, 0x63,
2263 0x53, 0x53, 0x47,
2264 0x2e,
Laurence Lundblade59289e52019-12-30 13:44:37 -08002265 0xd0, 0xd1, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0x69,
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002266 0x43, 0x6f, 0x6e, 0x66, 0x75, 0x73, 0x69, 0x6f, 0x6e,
2267 0xd1, 0x2f,
2268 0xd1, 0x69,
2269 0x53, 0x61, 0x6e, 0x20, 0x44, 0x69, 0x65, 0x67, 0x6f,
2270 0xd1, 0x2d,
2271 0xd1, 0x62,
2272 0x55, 0x53,
2273 0xd7, 0x32,
2274 0xd3, 0xa2,
2275 0x2a,
2276 0xc9, 0xa1,
2277 0x28,
2278 0x26,
2279 0xda, 0x05, 0x66, 0x70, 0x89, 0xda, 0x05, 0x66, 0x70, 0x89, 0xda, 0x05, 0x66, 0x70, 0x89, 0x29,
2280 0xcc, 0x4a,
2281 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,0x07, 0x08, 0x09, 0x0a,
2282 0xd0, 0x35,
2283 0xd7, 0xa1,
2284 0xcb, 0xc8, 0xc7, 0x24,
2285 0xc8, 0x22};
2286
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002287static int32_t CheckCSRMaps(QCBORDecodeContext *pDC);
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002288
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002289
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002290int32_t OptTagParseTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002291{
2292 QCBORDecodeContext DCtx;
2293 QCBORItem Item;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002294
Laurence Lundbladeee851742020-01-08 08:37:05 -08002295 QCBORDecode_Init(&DCtx,
2296 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spOptTestInput),
2297 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002298
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002299 //-------------------------
2300 // This text matches the magic number tag and the fraction tag
2301 if(QCBORDecode_GetNext(&DCtx, &Item)) {
2302 return -2;
2303 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002304 if(Item.uDataType != QCBOR_TYPE_ARRAY ||
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002305 !QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_CBOR_MAGIC)) {
2306 return -3;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002307 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002308
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002309 if(QCBORDecode_GetNext(&DCtx, &Item)) {
2310 return -4;
2311 }
Laurence Lundblade59289e52019-12-30 13:44:37 -08002312
2313#ifdef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002314 if(Item.uDataType != QCBOR_TYPE_ARRAY ||
Laurence Lundblade59289e52019-12-30 13:44:37 -08002315 !QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_DECIMAL_FRACTION) ||
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002316 Item.val.uCount != 2) {
2317 return -5;
2318 }
Laurence Lundblade59289e52019-12-30 13:44:37 -08002319#else
2320 if(Item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION) {
2321 return -6;
2322 }
2323#endif
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002324
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002325 // --------------------------------
2326 // This test decodes the very large tag, but it is not in
2327 // any list so it is ignored.
Laurence Lundbladeee851742020-01-08 08:37:05 -08002328 QCBORDecode_Init(&DCtx,
2329 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spEncodedLargeTag),
2330 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002331 if(QCBORDecode_GetNext(&DCtx, &Item)) {
2332 return -6;
2333 }
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002334 /*
2335 if(Item.uTagBits) { // TODO: make sure it is OK to remove this
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002336 return -7;
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002337 }*/
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002338
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002339 // ----------------------------------
Laurence Lundbladeee851742020-01-08 08:37:05 -08002340 // This test sets up a caller-config list that includes the very large
2341 // tage and then matches it.
2342 QCBORDecode_Init(&DCtx,
2343 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spEncodedLargeTag),
2344 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002345 const uint64_t puList[] = {0x9192939495969798, 257};
2346 const QCBORTagListIn TL = {2, puList};
2347 QCBORDecode_SetCallerConfiguredTagList(&DCtx, &TL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002348
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002349 if(QCBORDecode_GetNext(&DCtx, &Item)) {
2350 return -8;
2351 }
2352 if(Item.uDataType != QCBOR_TYPE_ARRAY ||
2353 !QCBORDecode_IsTagged(&DCtx, &Item, 0x9192939495969798) ||
2354 QCBORDecode_IsTagged(&DCtx, &Item, 257) ||
2355 QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_BIGFLOAT) ||
2356 Item.val.uCount != 0) {
2357 return -9;
2358 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002359
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002360 //------------------------
Laurence Lundbladeee851742020-01-08 08:37:05 -08002361 // Sets up a caller-configured list and look up something not in it
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002362 const uint64_t puLongList[17] = {1,2,1};
2363 const QCBORTagListIn TLLong = {17, puLongList};
Laurence Lundbladeee851742020-01-08 08:37:05 -08002364 QCBORDecode_Init(&DCtx,
2365 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spEncodedLargeTag),
2366 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002367 QCBORDecode_SetCallerConfiguredTagList(&DCtx, &TLLong);
2368 if(QCBORDecode_GetNext(&DCtx, &Item)) {
2369 return -11;
2370 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002371
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002372 // -----------------------
2373 // This tests retrievel of the full tag list
Laurence Lundbladeee851742020-01-08 08:37:05 -08002374 QCBORDecode_Init(&DCtx,
2375 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spLotsOfTags),
2376 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002377 uint64_t puTags[16];
2378 QCBORTagListOut Out = {0, 4, puTags};
2379 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2380 return -12;
2381 }
2382 if(puTags[0] != 0x9192939495969798 ||
2383 puTags[1] != 0x88 ||
Laurence Lundblade59289e52019-12-30 13:44:37 -08002384 puTags[2] != 0x06 ||
2385 puTags[3] != 0x07) {
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002386 return -13;
2387 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002388
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002389 // ----------------------
2390 // This text if too small of an out list
Laurence Lundbladeee851742020-01-08 08:37:05 -08002391 QCBORDecode_Init(&DCtx,
2392 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spLotsOfTags),
2393 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002394 QCBORTagListOut OutSmall = {0, 3, puTags};
2395 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &OutSmall) != QCBOR_ERR_TOO_MANY_TAGS) {
2396 return -14;
2397 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002398
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002399#if 0
2400 // TODO: this test needs to be re evaluated
2401
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002402 // ---------------
2403 // Parse a version of the "CSR" that has had a ton of tags randomly inserted
Laurence Lundbladeee851742020-01-08 08:37:05 -08002404 QCBORDecode_Init(&DCtx,
2405 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spCSRWithTags),
2406 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002407 int n = CheckCSRMaps(&DCtx);
2408 if(n) {
2409 return n-2000;
2410 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002411
Laurence Lundblade59289e52019-12-30 13:44:37 -08002412 Out = (QCBORTagListOut){0, 16, puTags};
Laurence Lundbladeee851742020-01-08 08:37:05 -08002413 QCBORDecode_Init(&DCtx,
2414 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spCSRWithTags),
2415 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002416
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002417 const uint64_t puTagList[] = {773, 1, 90599561};
2418 const QCBORTagListIn TagList = {3, puTagList};
2419 QCBORDecode_SetCallerConfiguredTagList(&DCtx, &TagList);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002420
2421
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002422 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2423 return -100;
2424 }
2425 if(Item.uDataType != QCBOR_TYPE_MAP ||
2426 !QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_CBOR_MAGIC) ||
2427 QCBORDecode_IsTagged(&DCtx, &Item, 90599561) ||
2428 QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_DATE_EPOCH) ||
2429 Item.val.uCount != 2 ||
2430 puTags[0] != CBOR_TAG_CBOR_MAGIC ||
2431 puTags[1] != CBOR_TAG_CBOR_MAGIC ||
2432 puTags[2] != CBOR_TAG_CBOR_MAGIC ||
2433 Out.uNumUsed != 3) {
2434 return -101;
2435 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002436
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002437 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2438 return -102;
2439 }
2440 if(Item.uDataType != QCBOR_TYPE_MAP ||
2441 QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_CBOR_MAGIC) ||
2442 QCBORDecode_IsTagged(&DCtx, &Item, 6) ||
2443 QCBORDecode_IsTagged(&DCtx, &Item, 7) || // item is tagged 7, but 7 is not configured to be recognized
2444 Item.val.uCount != 2 ||
2445 puTags[0] != 5859837686836516696 ||
2446 puTags[1] != 7 ||
2447 Out.uNumUsed != 2) {
2448 return -103;
2449 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002450
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002451 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2452 return -104;
2453 }
2454 if(Item.uDataType != QCBOR_TYPE_MAP ||
2455 Item.uTagBits ||
2456 Item.val.uCount != 5 ||
2457 puTags[0] != 0x0b ||
2458 Out.uNumUsed != 1) {
2459 return -105;
2460 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002461
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002462 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2463 return -106;
2464 }
2465 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
2466 !QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_COSE_MAC0) ||
2467 Item.val.string.len != 12 ||
2468 puTags[0] != CBOR_TAG_COSE_MAC0 ||
2469 puTags[1] != CBOR_TAG_COSE_MAC0 ||
2470 puTags[2] != CBOR_TAG_COSE_MAC0 ||
2471 Out.uNumUsed != 3) {
2472 return -105;
2473 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002474
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002475 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2476 return -107;
2477 }
2478 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
2479 !QCBORDecode_IsTagged(&DCtx, &Item, 773) ||
2480 Item.val.string.len != 3 ||
2481 puTags[0] != 773 ||
2482 Out.uNumUsed != 1) {
2483 return -108;
2484 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002485
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002486 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2487 return -109;
2488 }
2489 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundblade59289e52019-12-30 13:44:37 -08002490 !QCBORDecode_IsTagged(&DCtx, &Item, 16) ||
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002491 Item.val.string.len != 9 ||
Laurence Lundblade59289e52019-12-30 13:44:37 -08002492 puTags[0] != 16 ||
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002493 puTags[11] != 0x0f ||
2494 Out.uNumUsed != 12) {
2495 return -110;
2496 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002497
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002498 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2499 return -111;
2500 }
2501 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
2502 !QCBORDecode_IsTagged(&DCtx, &Item, 17) ||
2503 Item.val.string.len != 9 ||
2504 puTags[0] != 17 ||
2505 Out.uNumUsed != 1) {
2506 return -112;
2507 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002508
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002509 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2510 return -111;
2511 }
2512 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
2513 !QCBORDecode_IsTagged(&DCtx, &Item, 17) ||
2514 Item.val.string.len != 2 ||
2515 puTags[0] != 17 ||
2516 Out.uNumUsed != 1) {
2517 return -112;
2518 }
2519
2520 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2521 return -113;
2522 }
2523 if(Item.uDataType != QCBOR_TYPE_MAP ||
2524 QCBORDecode_IsTagged(&DCtx, &Item, 19) ||
2525 Item.val.uCount != 2 ||
2526 puTags[0] != 19 ||
2527 Out.uNumUsed != 1) {
2528 return -114;
2529 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002530
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002531 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2532 return -115;
2533 }
2534 if(Item.uDataType != QCBOR_TYPE_MAP ||
2535 QCBORDecode_IsTagged(&DCtx, &Item, 9) ||
2536 Item.uTagBits ||
2537 Item.val.uCount != 1 ||
2538 puTags[0] != 9 ||
2539 Out.uNumUsed != 1) {
2540 return -116;
2541 }
2542
2543 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2544 return -116;
2545 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002546 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002547 Item.val.int64 != -7 ||
2548 Item.uTagBits ||
2549 Out.uNumUsed != 0) {
2550 return -117;
2551 }
2552
2553 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2554 return -118;
2555 }
2556 if(Item.uDataType != QCBOR_TYPE_BYTE_STRING ||
2557 Item.val.string.len != 10 ||
2558 Item.uTagBits ||
2559 puTags[0] != 12 ||
2560 Out.uNumUsed != 1) {
2561 return -119;
2562 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002563
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002564 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2565 return -120;
2566 }
2567 if(Item.uDataType != QCBOR_TYPE_MAP ||
2568 !QCBORDecode_IsTagged(&DCtx, &Item, CBOR_TAG_ENC_AS_B16) ||
2569 Item.val.uCount != 1 ||
2570 puTags[0] != 0x17 ||
2571 Out.uNumUsed != 1) {
2572 return -121;
2573 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002574
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002575 if(QCBORDecode_GetNextWithTags(&DCtx, &Item, &Out)) {
2576 return -122;
2577 }
2578 if(Item.uDataType != QCBOR_TYPE_INT64 ||
2579 QCBORDecode_IsTagged(&DCtx, &Item, 8) ||
2580 Item.val.int64 != -3 ||
2581 puTags[0] != 8 ||
2582 Out.uNumUsed != 1) {
2583 return -123;
2584 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002585
Laurence Lundbladedbe6f212018-10-28 11:37:53 +07002586 if(QCBORDecode_Finish(&DCtx)) {
2587 return -124;
2588 }
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002589#else
2590 (void)spCSRWithTags;
2591#endif
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002592 return 0;
2593}
2594
2595
2596
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002597
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002598static uint8_t spBigNumInput[] = {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002599 0x83,
2600 0xC2, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2601 0xC3, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2602 0xA4,
2603 0x63, 0x42, 0x4E, 0x2B,
2604 0xC2, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2605 0x18, 0x40,
2606 0xC2, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2607 0x63, 0x42, 0x4E, 0x2D,
2608 0xC3, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2609 0x38, 0x3F,
2610 0xC3, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
2611
2612
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002613static uint8_t spBigNum[] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002614
2615
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002616int32_t BignumParseTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002617{
2618 QCBORDecodeContext DCtx;
2619 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07002620 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002621
Laurence Lundbladeee851742020-01-08 08:37:05 -08002622 QCBORDecode_Init(&DCtx,
2623 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNumInput),
2624 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002625
2626
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002627 //
2628 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
2629 return -1;
2630 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002631 return -2;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002632 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002633
2634 //
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002635 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002636 return -3;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002637 if(Item.uDataType != QCBOR_TYPE_POSBIGNUM ||
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002638 UsefulBuf_Compare(Item.val.bigNum, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNum))){
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002639 return -4;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002640 }
2641
2642 //
2643 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002644 return -5;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002645 if(Item.uDataType != QCBOR_TYPE_NEGBIGNUM ||
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002646 UsefulBuf_Compare(Item.val.bigNum, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNum))){
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002647 return -6;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002648 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002649
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002650 //
2651 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002652 return -7;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002653 if(Item.uDataType != QCBOR_TYPE_MAP) {
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002654 return -8;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002655 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002656
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002657 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002658 return -9;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002659 if(Item.uDataType != QCBOR_TYPE_POSBIGNUM ||
2660 Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002661 UsefulBuf_Compare(Item.val.bigNum, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNum))){
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002662 return -10;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002663 }
2664
2665 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002666 return -11;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002667 if(Item.uDataType != QCBOR_TYPE_POSBIGNUM ||
2668 Item.uLabelType != QCBOR_TYPE_INT64 ||
2669 Item.label.int64 != 64 ||
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002670 UsefulBuf_Compare(Item.val.bigNum, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNum))){
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002671 return -12;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002672 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002673
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002674 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002675 return -13;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002676 if(Item.uDataType != QCBOR_TYPE_NEGBIGNUM ||
2677 Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002678 UsefulBuf_Compare(Item.val.bigNum, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNum))){
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002679 return -14;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002680 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002681
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002682 if((nCBORError = QCBORDecode_GetNext(&DCtx, &Item)))
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002683 return -15;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002684 if(Item.uDataType != QCBOR_TYPE_NEGBIGNUM ||
2685 Item.uLabelType != QCBOR_TYPE_INT64 ||
2686 Item.label.int64 != -64 ||
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002687 UsefulBuf_Compare(Item.val.bigNum, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNum))){
Laurence Lundblade830fbf92020-05-31 17:22:33 -07002688 return -16;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002689 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002690
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002691 return 0;
2692}
2693
2694
2695
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002696static int32_t CheckItemWithIntLabel(QCBORDecodeContext *pCtx,
Laurence Lundbladeee851742020-01-08 08:37:05 -08002697 uint8_t uDataType,
2698 uint8_t uNestingLevel,
2699 uint8_t uNextNest,
2700 int64_t nLabel,
2701 QCBORItem *pItem)
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002702{
2703 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07002704 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002705
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002706 if((nCBORError = QCBORDecode_GetNext(pCtx, &Item))) return -1;
2707 if(Item.uDataType != uDataType) return -1;
2708 if(uNestingLevel > 0) {
Laurence Lundbladeee851742020-01-08 08:37:05 -08002709 if(Item.uLabelType != QCBOR_TYPE_INT64 &&
2710 Item.uLabelType != QCBOR_TYPE_UINT64) {
2711 return -1;
2712 }
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002713 if(Item.uLabelType == QCBOR_TYPE_INT64) {
2714 if(Item.label.int64 != nLabel) return -1;
2715 } else {
Laurence Lundblade570fab52018-10-13 18:28:27 +08002716 if(Item.label.uint64 != (uint64_t)nLabel) return -1;
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002717 }
2718 }
2719 if(Item.uNestingLevel != uNestingLevel) return -1;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302720 if(Item.uNextNestLevel != uNextNest) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002721
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002722 if(pItem) {
2723 *pItem = Item;
2724 }
2725 return 0;
2726}
2727
2728
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002729// Same code checks definite and indefinite length versions of the map
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002730static int32_t CheckCSRMaps(QCBORDecodeContext *pDC)
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002731{
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302732 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_MAP, 0, 1, 0, NULL)) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002733
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302734 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_MAP, 1, 2, -23, NULL)) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002735
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302736 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_MAP, 2, 3, -20, NULL)) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002737
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302738 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_TEXT_STRING, 3, 3, -18, NULL)) return -1;
2739 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_TEXT_STRING, 3, 3, -17, NULL)) return -1;
2740 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_TEXT_STRING, 3, 3, -15, NULL)) return -1;
2741 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_TEXT_STRING, 3, 3, -16, NULL)) return -1;
2742 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_TEXT_STRING, 3, 2, -14, NULL)) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002743
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302744 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_MAP, 2, 3, -19, NULL)) return -1;
2745 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_MAP, 3, 4, -11, NULL)) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002746
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302747 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_INT64, 4, 3, -9, NULL)) return -1;
2748 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_BYTE_STRING, 3, 1, -10, NULL)) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002749
Laurence Lundbladea44d5062018-10-17 18:45:12 +05302750 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_MAP, 1, 2, -22, NULL)) return -1;
2751 if(CheckItemWithIntLabel(pDC, QCBOR_TYPE_INT64, 2, 0, -5, NULL)) return -1;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002752
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002753 if(QCBORDecode_Finish(pDC)) return -2;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002754
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002755 return 0;
2756}
2757
2758
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002759/*
2760// cbor.me decoded output
2761{
2762 -23: {
2763 -20: {
2764 -18: "Organization",
2765 -17: "SSG",
2766 -15: "Confusion",
2767 -16: "San Diego",
2768 -14: "US"
2769 },
2770 -19: {
2771 -11: {
2772 -9: -7
2773 },
2774 -10: '\u0001\u0002\u0003\u0004\u0005\u0006\a\b\t\n'
2775 }
2776 },
2777 -22: {
2778 -5: -3
2779 }
2780}
2781 */
2782
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002783
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002784static uint8_t spCSRInput[] = {
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002785 0xa2, 0x36, 0xa2, 0x33, 0xa5, 0x31, 0x6c, 0x4f,
2786 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74,
2787 0x69, 0x6f, 0x6e, 0x30, 0x63, 0x53, 0x53, 0x47,
2788 0x2e, 0x69, 0x43, 0x6f, 0x6e, 0x66, 0x75, 0x73,
2789 0x69, 0x6f, 0x6e, 0x2f, 0x69, 0x53, 0x61, 0x6e,
2790 0x20, 0x44, 0x69, 0x65, 0x67, 0x6f, 0x2d, 0x62,
2791 0x55, 0x53, 0x32, 0xa2, 0x2a, 0xa1, 0x28, 0x26,
2792 0x29, 0x4a, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
2793 0x07, 0x08, 0x09, 0x0a, 0x35, 0xa1, 0x24, 0x22};
2794
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002795int32_t NestedMapTest()
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002796{
2797 QCBORDecodeContext DCtx;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002798
Laurence Lundbladeee851742020-01-08 08:37:05 -08002799 QCBORDecode_Init(&DCtx,
2800 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spCSRInput),
2801 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002802
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002803 return CheckCSRMaps(&DCtx);
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002804}
2805
Laurence Lundbladeea567ac2018-12-09 14:03:21 -08002806
2807
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002808int32_t StringDecoderModeFailTest()
Laurence Lundbladeea567ac2018-12-09 14:03:21 -08002809{
2810 QCBORDecodeContext DCtx;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002811
Laurence Lundbladeee851742020-01-08 08:37:05 -08002812 QCBORDecode_Init(&DCtx,
2813 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spCSRInput),
2814 QCBOR_DECODE_MODE_MAP_STRINGS_ONLY);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002815
Laurence Lundbladeea567ac2018-12-09 14:03:21 -08002816 QCBORItem Item;
2817 QCBORError nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002818
Laurence Lundbladeea567ac2018-12-09 14:03:21 -08002819 if(QCBORDecode_GetNext(&DCtx, &Item)) {
2820 return -1;
2821 }
2822 if(Item.uDataType != QCBOR_TYPE_MAP) {
2823 return -2;
2824 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002825
Laurence Lundbladeea567ac2018-12-09 14:03:21 -08002826 nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
2827 if(nCBORError != QCBOR_ERR_MAP_LABEL_TYPE) {
2828 return -3;
2829 }
2830
2831 return 0;
2832}
2833
2834
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002835// Same map as above, but using indefinite lengths
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002836static uint8_t spCSRInputIndefLen[] = {
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002837 0xbf, 0x36, 0xbf, 0x33, 0xbf, 0x31, 0x6c, 0x4f,
2838 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74,
2839 0x69, 0x6f, 0x6e, 0x30, 0x63, 0x53, 0x53, 0x47,
2840 0x2e, 0x69, 0x43, 0x6f, 0x6e, 0x66, 0x75, 0x73,
2841 0x69, 0x6f, 0x6e, 0x2f, 0x69, 0x53, 0x61, 0x6e,
2842 0x20, 0x44, 0x69, 0x65, 0x67, 0x6f, 0x2d, 0x62,
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002843 0x55, 0x53, 0xff, 0x32, 0xbf, 0x2a, 0xbf, 0x28,
2844 0x26, 0xff, 0x29, 0x4a, 0x01, 0x02, 0x03, 0x04,
2845 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0xff, 0xff,
2846 0x35, 0xbf, 0x24, 0x22, 0xff, 0xff};
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002847
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002848int32_t NestedMapTestIndefLen()
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002849{
2850 QCBORDecodeContext DCtx;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002851
Laurence Lundbladeee851742020-01-08 08:37:05 -08002852 QCBORDecode_Init(&DCtx,
2853 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spCSRInputIndefLen),
2854 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002855
Laurence Lundblade742df4a2018-10-13 20:07:17 +08002856 return CheckCSRMaps(&DCtx);
2857}
2858
2859
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08002860
Laurence Lundblade17ede402018-10-13 11:43:07 +08002861static UsefulBufC make_nested_indefinite_arrays(int n, UsefulBuf Storage)
2862{
2863 UsefulOutBuf UOB;
2864 UsefulOutBuf_Init(&UOB, Storage);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002865
Laurence Lundblade17ede402018-10-13 11:43:07 +08002866 int i;
2867 for(i = 0; i < n; i++) {
2868 UsefulOutBuf_AppendByte(&UOB, 0x9f);
2869 }
2870
2871 for(i = 0; i < n; i++) {
2872 UsefulOutBuf_AppendByte(&UOB, 0xff);
2873 }
2874 return UsefulOutBuf_OutUBuf(&UOB);
2875}
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002876
2877
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002878static int32_t parse_indeflen_nested(UsefulBufC Nested, int nNestLevel)
Laurence Lundblade17ede402018-10-13 11:43:07 +08002879{
2880 QCBORDecodeContext DC;
2881 QCBORDecode_Init(&DC, Nested, 0);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002882
Laurence Lundblade17ede402018-10-13 11:43:07 +08002883 int j;
2884 for(j = 0; j < nNestLevel; j++) {
2885 QCBORItem Item;
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07002886 QCBORError nReturn = QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade17ede402018-10-13 11:43:07 +08002887 if(j >= QCBOR_MAX_ARRAY_NESTING) {
2888 // Should be in error
2889 if(nReturn != QCBOR_ERR_ARRAY_NESTING_TOO_DEEP) {
2890 return -4;
2891 } else {
2892 return 0; // Decoding doesn't recover after an error
2893 }
2894 } else {
2895 // Should be no error
2896 if(nReturn) {
2897 return -9; // Should not have got an error
2898 }
2899 }
2900 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
2901 return -7;
2902 }
2903 }
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07002904 QCBORError nReturn = QCBORDecode_Finish(&DC);
Laurence Lundblade17ede402018-10-13 11:43:07 +08002905 if(nReturn) {
2906 return -3;
2907 }
2908 return 0;
2909}
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002910
2911
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002912int32_t IndefiniteLengthNestTest()
Laurence Lundblade17ede402018-10-13 11:43:07 +08002913{
Laurence Lundblade4fe9f312018-10-22 10:22:39 +05302914 UsefulBuf_MAKE_STACK_UB(Storage, 50);
Laurence Lundblade17ede402018-10-13 11:43:07 +08002915 int i;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002916 for(i=1; i < QCBOR_MAX_ARRAY_NESTING+4; i++) {
Laurence Lundblade25c6c0a2018-12-17 13:21:59 -08002917 const UsefulBufC Nested = make_nested_indefinite_arrays(i, Storage);
Laurence Lundblade17ede402018-10-13 11:43:07 +08002918 int nReturn = parse_indeflen_nested(Nested, i);
2919 if(nReturn) {
2920 return nReturn;
2921 }
2922 }
2923 return 0;
2924}
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002925
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002926
Laurence Lundbladeee851742020-01-08 08:37:05 -08002927// [1, [2, 3]]
2928static const uint8_t spIndefiniteArray[] = {0x9f, 0x01, 0x82, 0x02, 0x03, 0xff};
2929// No closing break
2930static const uint8_t spIndefiniteArrayBad1[] = {0x9f};
2931// Not enough closing breaks
2932static const uint8_t spIndefiniteArrayBad2[] = {0x9f, 0x9f, 0x02, 0xff};
2933// Too many closing breaks
2934static const uint8_t spIndefiniteArrayBad3[] = {0x9f, 0x02, 0xff, 0xff};
2935// Unclosed indeflen inside def len
2936static const uint8_t spIndefiniteArrayBad4[] = {0x81, 0x9f};
2937// confused tag
2938static const uint8_t spIndefiniteArrayBad5[] = {0x9f, 0xd1, 0xff};
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002939
Laurence Lundbladec5fef682020-01-25 11:38:45 -08002940int32_t IndefiniteLengthArrayMapTest()
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002941{
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07002942 QCBORError nResult;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08002943 // --- first test -----
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002944 UsefulBufC IndefLen = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteArray);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002945
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002946 // Decode it and see if it is OK
Laurence Lundblade4fe9f312018-10-22 10:22:39 +05302947 UsefulBuf_MAKE_STACK_UB(MemPool, 150);
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002948 QCBORDecodeContext DC;
2949 QCBORItem Item;
2950 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002951
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002952 QCBORDecode_SetMemPool(&DC, MemPool, false);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002953
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002954 QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade6de37062018-10-15 12:22:42 +05302955
2956 if(Item.uDataType != QCBOR_TYPE_ARRAY ||
2957 Item.uNestingLevel != 0 ||
2958 Item.uNextNestLevel != 1) {
2959 return -111;
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002960 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002961
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002962 QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade6de37062018-10-15 12:22:42 +05302963 if(Item.uDataType != QCBOR_TYPE_INT64 ||
2964 Item.uNestingLevel != 1 ||
2965 Item.uNextNestLevel != 1) {
2966 return -2;
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002967 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002968
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002969 QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade6de37062018-10-15 12:22:42 +05302970 if(Item.uDataType != QCBOR_TYPE_ARRAY ||
2971 Item.uNestingLevel != 1 ||
2972 Item.uNextNestLevel != 2) {
2973 return -3;
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002974 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002975
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002976 QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade12b495d2018-12-17 11:15:54 -08002977 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade6de37062018-10-15 12:22:42 +05302978 Item.uNestingLevel != 2 ||
2979 Item.uNextNestLevel != 2) {
2980 return -4;
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002981 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002982
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002983 QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade12b495d2018-12-17 11:15:54 -08002984 if(Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade6de37062018-10-15 12:22:42 +05302985 Item.uNestingLevel != 2 ||
2986 Item.uNextNestLevel != 0) {
2987 return -5;
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002988 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002989
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002990 if(QCBORDecode_Finish(&DC)) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05302991 return -6;
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08002992 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002993
Laurence Lundblade19e0c802018-10-13 12:19:55 +08002994 // --- next test -----
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07002995 IndefLen = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteArrayBad1);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002996
Laurence Lundblade19e0c802018-10-13 12:19:55 +08002997 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08002998
Laurence Lundblade19e0c802018-10-13 12:19:55 +08002999 QCBORDecode_SetMemPool(&DC, MemPool, false);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003000
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003001 nResult = QCBORDecode_GetNext(&DC, &Item);
3002 if(nResult || Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303003 return -7;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003004 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003005
Laurence Lundblade570fab52018-10-13 18:28:27 +08003006 nResult = QCBORDecode_Finish(&DC);
Laurence Lundblade6de37062018-10-15 12:22:42 +05303007 if(nResult != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
3008 return -8;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003009 }
3010
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003011
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003012 // --- next test -----
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003013 IndefLen = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteArrayBad2);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003014
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003015 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003016
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003017 QCBORDecode_SetMemPool(&DC, MemPool, false);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003018
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003019 nResult = QCBORDecode_GetNext(&DC, &Item);
3020 if(nResult || Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303021 return -9;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003022 }
3023
3024 nResult = QCBORDecode_GetNext(&DC, &Item);
3025 if(nResult || Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303026 return -10;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003027 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003028
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003029 nResult = QCBORDecode_GetNext(&DC, &Item);
3030 if(nResult || Item.uDataType != QCBOR_TYPE_INT64) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303031 return -11;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003032 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003033
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003034 nResult = QCBORDecode_Finish(&DC);
Laurence Lundblade6de37062018-10-15 12:22:42 +05303035 if(nResult != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
3036 return -12;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003037 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003038
3039
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003040 // --- next test -----
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003041 IndefLen = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteArrayBad3);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003042
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003043 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003044
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003045 QCBORDecode_SetMemPool(&DC, MemPool, false);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003046
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003047 nResult = QCBORDecode_GetNext(&DC, &Item);
3048 if(nResult || Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303049 return -13;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003050 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003051
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003052 nResult = QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade642282a2020-06-23 12:00:33 -07003053 if(nResult != QCBOR_SUCCESS) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303054 return -14;
Laurence Lundblade19e0c802018-10-13 12:19:55 +08003055 }
Laurence Lundblade6de37062018-10-15 12:22:42 +05303056
Laurence Lundblade642282a2020-06-23 12:00:33 -07003057 nResult = QCBORDecode_GetNext(&DC, &Item);
3058 if(nResult != QCBOR_ERR_BAD_BREAK) {
3059 return -140;
3060 }
3061
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003062
Laurence Lundblade570fab52018-10-13 18:28:27 +08003063 // --- next test -----
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003064 IndefLen = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteArrayBad4);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003065
Laurence Lundblade570fab52018-10-13 18:28:27 +08003066 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003067
Laurence Lundblade570fab52018-10-13 18:28:27 +08003068 QCBORDecode_SetMemPool(&DC, MemPool, false);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003069
Laurence Lundblade570fab52018-10-13 18:28:27 +08003070 nResult = QCBORDecode_GetNext(&DC, &Item);
3071 if(nResult || Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303072 return -15;
Laurence Lundblade570fab52018-10-13 18:28:27 +08003073 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003074
Laurence Lundblade570fab52018-10-13 18:28:27 +08003075 nResult = QCBORDecode_GetNext(&DC, &Item);
3076 if(nResult || Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303077 return -16;
Laurence Lundblade570fab52018-10-13 18:28:27 +08003078 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003079
Laurence Lundblade570fab52018-10-13 18:28:27 +08003080 nResult = QCBORDecode_Finish(&DC);
Laurence Lundblade6de37062018-10-15 12:22:42 +05303081 if(nResult != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
3082 return -17;
Laurence Lundblade570fab52018-10-13 18:28:27 +08003083 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003084
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303085 // --- next test -----
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003086 IndefLen = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteArrayBad5);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003087
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303088 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003089
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303090 QCBORDecode_SetMemPool(&DC, MemPool, false);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003091
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303092 nResult = QCBORDecode_GetNext(&DC, &Item);
3093 if(nResult || Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade6de37062018-10-15 12:22:42 +05303094 return -18;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303095 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003096
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303097 nResult = QCBORDecode_GetNext(&DC, &Item);
Laurence Lundblade6de37062018-10-15 12:22:42 +05303098 if(nResult != QCBOR_ERR_BAD_BREAK) {
3099 return -19;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303100 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003101
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08003102 return 0;
3103}
3104
Laurence Lundblade17ede402018-10-13 11:43:07 +08003105
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003106static const uint8_t spIndefiniteLenString[] = {
Laurence Lundblade17ede402018-10-13 11:43:07 +08003107 0x81, // Array of length one
3108 0x7f, // text string marked with indefinite length
3109 0x65, 0x73, 0x74, 0x72, 0x65, 0x61, // first segment
3110 0x64, 0x6d, 0x69, 0x6e, 0x67, // second segment
3111 0xff // ending break
3112};
3113
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003114static const uint8_t spIndefiniteLenStringBad2[] = {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303115 0x81, // Array of length one
3116 0x7f, // text string marked with indefinite length
3117 0x65, 0x73, 0x74, 0x72, 0x65, 0x61, // first segment
3118 0x44, 0x6d, 0x69, 0x6e, 0x67, // second segment of wrong type
3119 0xff // ending break
3120};
3121
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003122static const uint8_t spIndefiniteLenStringBad3[] = {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303123 0x81, // Array of length one
3124 0x7f, // text string marked with indefinite length
3125 0x01, 0x02, // Not a string
3126 0xff // ending break
3127};
3128
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003129static const uint8_t spIndefiniteLenStringBad4[] = {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303130 0x81, // Array of length one
3131 0x7f, // text string marked with indefinite length
3132 0x65, 0x73, 0x74, 0x72, 0x65, 0x61, // first segment
3133 0x64, 0x6d, 0x69, 0x6e, 0x67, // second segment
3134 // missing end of string
3135};
3136
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003137static const uint8_t spIndefiniteLenStringLabel[] = {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303138 0xa1, // Array of length one
3139 0x7f, // text string marked with indefinite length
3140 0x65, 0x73, 0x74, 0x72, 0x75, 0x75, // first segment
3141 0x64, 0x6d, 0x69, 0x6e, 0x67, // second segment
3142 0xff, // ending break
3143 0x01 // integer being labeled.
3144};
3145
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003146/**
3147 Make an indefinite length string
3148
3149 @param Storage Storage for string, must be 144 bytes in size
3150 @return The indefinite length string
3151
3152 This makes an array with one indefinite length string that has 7 chunks
3153 from size of 1 byte up to 64 bytes.
3154 */
3155static UsefulBufC MakeIndefiniteBigBstr(UsefulBuf Storage)
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303156{
3157 UsefulOutBuf UOB;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003158
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303159 UsefulOutBuf_Init(&UOB, Storage);
3160 UsefulOutBuf_AppendByte(&UOB, 0x81);
3161 UsefulOutBuf_AppendByte(&UOB, 0x5f);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003162
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003163 uint8_t uStringByte = 0;
3164 // Use of type int is intentional
3165 for(int uChunkSize = 1; uChunkSize <= 128; uChunkSize *= 2) {
3166 // Not using preferred encoding here, but that is OK.
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303167 UsefulOutBuf_AppendByte(&UOB, 0x58);
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003168 UsefulOutBuf_AppendByte(&UOB, (uint8_t)uChunkSize);
3169 for(int j = 0; j < uChunkSize; j++) {
3170 UsefulOutBuf_AppendByte(&UOB, uStringByte);
3171 uStringByte++;
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303172 }
3173 }
3174 UsefulOutBuf_AppendByte(&UOB, 0xff);
3175
3176 return UsefulOutBuf_OutUBuf(&UOB);
3177}
3178
3179static int CheckBigString(UsefulBufC BigString)
3180{
3181 if(BigString.len != 255) {
3182 return 1;
3183 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003184
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303185 for(uint8_t i = 0; i < 255; i++){
3186 if(((const uint8_t *)BigString.ptr)[i] != i) {
3187 return 1;
3188 }
3189 }
3190 return 0;
3191}
3192
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +05303193
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003194int32_t IndefiniteLengthStringTest()
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303195{
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303196 QCBORDecodeContext DC;
3197 QCBORItem Item;
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +05303198 // big enough for MakeIndefiniteBigBstr() + MemPool overhead
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003199 UsefulBuf_MAKE_STACK_UB(MemPool, 350);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003200
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303201 // --- Simple normal indefinite length string ------
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003202 UsefulBufC IndefLen = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteLenString);
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303203 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003204
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +05303205 if(QCBORDecode_SetMemPool(&DC, MemPool, false)) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303206 return -1;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303207 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003208
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303209 if(QCBORDecode_GetNext(&DC, &Item)) {
3210 return -2;
3211 }
3212 if(Item.uDataType != QCBOR_TYPE_ARRAY || Item.uDataAlloc) {
3213 return -3;
3214 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003215
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303216 if(QCBORDecode_GetNext(&DC, &Item)) {
3217 return -4;
3218 }
3219 if(Item.uDataType != QCBOR_TYPE_TEXT_STRING || !Item.uDataAlloc) {
3220 return -5;
3221 }
3222 if(QCBORDecode_Finish(&DC)) {
3223 return -6;
3224 }
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303225
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303226 // ----- types mismatch ---
Laurence Lundbladeee851742020-01-08 08:37:05 -08003227 QCBORDecode_Init(&DC,
3228 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteLenStringBad2),
3229 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003230
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303231 if(QCBORDecode_SetMemPool(&DC, MemPool, false)) {
3232 return -7;
3233 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003234
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303235 if(QCBORDecode_GetNext(&DC, &Item)) {
3236 return -8;
3237 }
3238 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
3239 return -9;
3240 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003241
Laurence Lundblade30816f22018-11-10 13:40:22 +07003242 if(QCBORDecode_GetNext(&DC, &Item) != QCBOR_ERR_INDEFINITE_STRING_CHUNK) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303243 return -10;
3244 }
3245
3246 // ----- not a string ---
Laurence Lundbladeee851742020-01-08 08:37:05 -08003247 QCBORDecode_Init(&DC,
3248 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteLenStringBad3),
3249 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003250
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303251 if(QCBORDecode_SetMemPool(&DC, MemPool, false)) {
3252 return -11;
3253 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003254
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303255 if(QCBORDecode_GetNext(&DC, &Item)) {
3256 return -12;
3257 }
3258 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
3259 return -13;
3260 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003261
Laurence Lundblade30816f22018-11-10 13:40:22 +07003262 if(QCBORDecode_GetNext(&DC, &Item) != QCBOR_ERR_INDEFINITE_STRING_CHUNK) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303263 return -14;
3264 }
3265
3266 // ----- no end -----
Laurence Lundbladeee851742020-01-08 08:37:05 -08003267 QCBORDecode_Init(&DC,
3268 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteLenStringBad4),
3269 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003270
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303271 if(QCBORDecode_SetMemPool(&DC, MemPool, false)) {
3272 return -15;
3273 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003274
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303275 if(QCBORDecode_GetNext(&DC, &Item)) {
3276 return -16;
3277 }
3278 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
3279 return -17;
3280 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003281
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303282 if(QCBORDecode_GetNext(&DC, &Item) != QCBOR_ERR_HIT_END) {
3283 return -18;
3284 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003285
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303286 // ------ Don't set a string allocator and see an error -----
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303287 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003288
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303289 QCBORDecode_GetNext(&DC, &Item);
3290 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303291 return -19;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303292 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003293
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303294 if(QCBORDecode_GetNext(&DC, &Item) != QCBOR_ERR_NO_STRING_ALLOCATOR) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303295 return -20;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303296 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003297
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303298 // ----- Mempool is way too small -----
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003299 UsefulBuf_MAKE_STACK_UB(MemPoolTooSmall, QCBOR_DECODE_MIN_MEM_POOL_SIZE-1);
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303300
3301 QCBORDecode_Init(&DC, IndefLen, QCBOR_DECODE_MODE_NORMAL);
3302 if(!QCBORDecode_SetMemPool(&DC, MemPoolTooSmall, false)) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303303 return -21;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303304 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003305
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303306 // ----- Mempool is way too small -----
Laurence Lundblade4fe9f312018-10-22 10:22:39 +05303307 UsefulBuf_MAKE_STACK_UB(BigIndefBStrStorage, 290);
Laurence Lundblade25c6c0a2018-12-17 13:21:59 -08003308 const UsefulBufC BigIndefBStr = MakeIndefiniteBigBstr(BigIndefBStrStorage);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003309
Laurence Lundbladeee851742020-01-08 08:37:05 -08003310 // 80 is big enough for MemPool overhead, but not BigIndefBStr
3311 UsefulBuf_MAKE_STACK_UB(MemPoolSmall, 80);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003312
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303313 QCBORDecode_Init(&DC, BigIndefBStr, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303314 if(QCBORDecode_SetMemPool(&DC, MemPoolSmall, false)) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303315 return -22;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303316 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003317
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303318 QCBORDecode_GetNext(&DC, &Item);
3319 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303320 return -23;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303321 }
Laurence Lundblade30816f22018-11-10 13:40:22 +07003322 if(QCBORDecode_GetNext(&DC, &Item) != QCBOR_ERR_STRING_ALLOCATE) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303323 return -24;
Laurence Lundblade5b8c5852018-10-14 21:11:42 +05303324 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003325
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303326 // ---- big bstr -----
3327 QCBORDecode_Init(&DC, BigIndefBStr, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003328
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303329 if(QCBORDecode_SetMemPool(&DC, MemPool, false)) {
3330 return -25;
3331 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003332
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +05303333 if(QCBORDecode_GetNext(&DC, &Item)) {
3334 return -26;
3335 }
3336 if(Item.uDataType != QCBOR_TYPE_ARRAY || Item.uDataAlloc) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303337 return -26;
3338 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003339
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303340 if(QCBORDecode_GetNext(&DC, &Item)) {
3341 return -27;
3342 }
Laurence Lundblade7e0d13b2018-10-16 19:54:13 +05303343 if(Item.uDataType != QCBOR_TYPE_BYTE_STRING || !Item.uDataAlloc || Item.uNestingLevel != 1) {
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303344 return -28;
3345 }
3346 if(CheckBigString(Item.val.string)) {
3347 return -3;
3348 }
3349 if(QCBORDecode_Finish(&DC)) {
3350 return -29;
3351 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003352
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303353 // --- label is an indefinite length string ------
Laurence Lundbladeb836efb2018-10-28 20:09:58 +07003354 QCBORDecode_Init(&DC, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spIndefiniteLenStringLabel), QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003355
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303356 if(QCBORDecode_SetMemPool(&DC, MemPool, false)) {
3357 return -30;
3358 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003359
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303360 QCBORDecode_GetNext(&DC, &Item);
3361 if(Item.uDataType != QCBOR_TYPE_MAP) {
3362 return -31;
3363 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003364
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303365 if(QCBORDecode_GetNext(&DC, &Item)){
3366 return -32;
3367 }
Laurence Lundbladeee851742020-01-08 08:37:05 -08003368 if(Item.uLabelType != QCBOR_TYPE_TEXT_STRING ||
3369 Item.uDataType != QCBOR_TYPE_INT64 ||
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303370 Item.uDataAlloc || !Item.uLabelAlloc ||
3371 UsefulBuf_Compare(Item.label.string, UsefulBuf_FromSZ("struuming"))) {
3372 return -33;
3373 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003374
Laurence Lundblade57dd1442018-10-15 20:26:28 +05303375 if(QCBORDecode_Finish(&DC)) {
3376 return -34;
3377 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003378
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003379 return 0;
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08003380}
3381
3382
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003383int32_t AllocAllStringsTest()
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303384{
3385 QCBORDecodeContext DC;
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003386 QCBORError nCBORError;
3387
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003388
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303389 // First test, use the "CSRMap" as easy input and checking
Laurence Lundbladeee851742020-01-08 08:37:05 -08003390 QCBORDecode_Init(&DC,
3391 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spCSRInput),
3392 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003393
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003394 UsefulBuf_MAKE_STACK_UB(Pool, sizeof(spCSRInput) + QCBOR_DECODE_MIN_MEM_POOL_SIZE);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003395
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003396 nCBORError = QCBORDecode_SetMemPool(&DC, Pool, 1); // Turn on copying.
3397 if(nCBORError) {
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303398 return -1;
3399 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003400
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003401 if(CheckCSRMaps(&DC)) {
3402 return -2;
3403 }
3404
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303405 // Next parse, save pointers to a few strings, destroy original and see all is OK.
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003406 UsefulBuf_MAKE_STACK_UB(CopyOfStorage, sizeof(pValidMapEncoded) + QCBOR_DECODE_MIN_MEM_POOL_SIZE);
Laurence Lundblade25c6c0a2018-12-17 13:21:59 -08003407 const UsefulBufC CopyOf = UsefulBuf_Copy(CopyOfStorage, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded));
Laurence Lundblade4d1ecba2018-10-12 21:22:30 +08003408
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303409 QCBORDecode_Init(&DC, CopyOf, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade1f8b5b02019-01-01 22:27:38 -08003410 UsefulBuf_Set(Pool, '/');
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303411 QCBORDecode_SetMemPool(&DC, Pool, 1); // Turn on copying.
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003412
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303413 QCBORItem Item1, Item2, Item3, Item4;
3414 if((nCBORError = QCBORDecode_GetNext(&DC, &Item1)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07003415 return (int32_t)nCBORError;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303416 if(Item1.uDataType != QCBOR_TYPE_MAP ||
3417 Item1.val.uCount != 3)
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003418 return -3;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303419 if((nCBORError = QCBORDecode_GetNext(&DC, &Item1)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07003420 return (int32_t)nCBORError;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303421 if((nCBORError = QCBORDecode_GetNext(&DC, &Item2)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07003422 return (int32_t)nCBORError;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303423 if((nCBORError = QCBORDecode_GetNext(&DC, &Item3)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07003424 return (int32_t)nCBORError;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303425 if((nCBORError = QCBORDecode_GetNext(&DC, &Item4)))
Laurence Lundbladee6bcef12020-04-01 10:56:27 -07003426 return (int32_t)nCBORError;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003427
Laurence Lundblade05ec57b2018-10-21 01:50:03 +05303428 UsefulBuf_Set(CopyOfStorage, '_');
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003429
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303430 if(Item1.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303431 Item1.uDataType != QCBOR_TYPE_INT64 ||
3432 Item1.val.int64 != 42 ||
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003433 Item1.uDataAlloc != 0 ||
3434 Item1.uLabelAlloc == 0 ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003435 UsefulBuf_Compare(Item1.label.string, UsefulBuf_FromSZ("first integer"))) {
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003436 return -4;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003437 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003438
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303439
3440 if(Item2.uLabelType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003441 UsefulBuf_Compare(Item2.label.string, UsefulBuf_FromSZ("an array of two strings")) ||
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303442 Item2.uDataType != QCBOR_TYPE_ARRAY ||
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003443 Item2.uDataAlloc != 0 ||
3444 Item2.uLabelAlloc == 0 ||
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303445 Item2.val.uCount != 2)
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003446 return -5;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003447
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303448 if(Item3.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003449 Item3.uDataAlloc == 0 ||
3450 Item3.uLabelAlloc != 0 ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003451 UsefulBuf_Compare(Item3.val.string, UsefulBuf_FromSZ("string1"))) {
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003452 return -6;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003453 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003454
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303455 if(Item4.uDataType != QCBOR_TYPE_TEXT_STRING ||
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003456 Item4.uDataAlloc == 0 ||
3457 Item4.uLabelAlloc != 0 ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003458 UsefulBuf_Compare(Item4.val.string, UsefulBuf_FromSZ("string2"))) {
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003459 return -7;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003460 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003461
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303462 // Next parse with a pool that is too small
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003463 UsefulBuf_MAKE_STACK_UB(SmallPool, QCBOR_DECODE_MIN_MEM_POOL_SIZE + 1);
Laurence Lundbladeee851742020-01-08 08:37:05 -08003464 QCBORDecode_Init(&DC,
3465 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded),
3466 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303467 QCBORDecode_SetMemPool(&DC, SmallPool, 1); // Turn on copying.
3468 if((nCBORError = QCBORDecode_GetNext(&DC, &Item1)))
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003469 return -8;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303470 if(Item1.uDataType != QCBOR_TYPE_MAP ||
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003471 Item1.val.uCount != 3) {
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003472 return -9;
Laurence Lundbladeccfb8cd2018-12-07 21:11:30 +09003473 }
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303474 if(!(nCBORError = QCBORDecode_GetNext(&DC, &Item1))){
3475 if(!(nCBORError = QCBORDecode_GetNext(&DC, &Item2))) {
3476 if(!(nCBORError = QCBORDecode_GetNext(&DC, &Item3))) {
3477 nCBORError = QCBORDecode_GetNext(&DC, &Item4);
3478 }
3479 }
3480 }
Laurence Lundblade30816f22018-11-10 13:40:22 +07003481 if(nCBORError != QCBOR_ERR_STRING_ALLOCATE) {
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003482 return -10;
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303483 }
3484
3485 return 0;
3486}
3487
Laurence Lundbladef6531662018-12-04 10:42:22 +09003488
Laurence Lundbladea44d5062018-10-17 18:45:12 +05303489
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003490int32_t MemPoolTest(void)
Laurence Lundblade0155b622018-10-12 20:04:37 +08003491{
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003492 // Set up the decoder with a tiny bit of CBOR to parse because
3493 // nothing can be done with it unless that is set up.
Laurence Lundbladef6531662018-12-04 10:42:22 +09003494 QCBORDecodeContext DC;
3495 const uint8_t pMinimalCBOR[] = {0xa0}; // One empty map
3496 QCBORDecode_Init(&DC, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pMinimalCBOR),0);
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003497
Laurence Lundbladef6531662018-12-04 10:42:22 +09003498 // Set up an memory pool of 100 bytes
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003499 // Then fish into the internals of the decode context
3500 // to get the allocator function so it can be called directly.
3501 // Also figure out how much pool is available for use
3502 // buy subtracting out the overhead.
Laurence Lundbladef6531662018-12-04 10:42:22 +09003503 UsefulBuf_MAKE_STACK_UB(Pool, 100);
Laurence Lundbladedf2836b2018-12-19 18:13:29 -08003504 QCBORError nError = QCBORDecode_SetMemPool(&DC, Pool, 0);
3505 if(nError) {
3506 return -9;
3507 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003508 QCBORStringAllocate pAlloc = DC.StringAllocator.pfAllocator;
3509 void *pAllocCtx = DC.StringAllocator.pAllocateCxt;
3510 size_t uAvailPool = Pool.len - QCBOR_DECODE_MIN_MEM_POOL_SIZE;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003511
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003512 // First test -- ask for one more byte than available and see failure
3513 UsefulBuf Allocated = (*pAlloc)(pAllocCtx, NULL, uAvailPool+1);
Laurence Lundbladef6531662018-12-04 10:42:22 +09003514 if(!UsefulBuf_IsNULL(Allocated)) {
3515 return -1;
3516 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003517
Laurence Lundbladef6531662018-12-04 10:42:22 +09003518 // Re do the set up for the next test that will do a successful alloc,
3519 // a fail, a free and then success
Laurence Lundbladef6531662018-12-04 10:42:22 +09003520 QCBORDecode_SetMemPool(&DC, Pool, 0);
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003521 pAlloc = DC.StringAllocator.pfAllocator;
3522 pAllocCtx = DC.StringAllocator.pAllocateCxt;
3523 uAvailPool = Pool.len - QCBOR_DECODE_MIN_MEM_POOL_SIZE;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003524
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003525 // Allocate one byte less than available and see success
3526 Allocated = (pAlloc)(pAllocCtx, NULL, uAvailPool-1);
Laurence Lundbladef6531662018-12-04 10:42:22 +09003527 if(UsefulBuf_IsNULL(Allocated)) { // expected to succeed
3528 return -2;
3529 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003530 // Ask for some more and see failure
3531 UsefulBuf Allocated2 = (*pAlloc)(pAllocCtx, NULL, uAvailPool/2);
Laurence Lundbladef6531662018-12-04 10:42:22 +09003532 if(!UsefulBuf_IsNULL(Allocated2)) { // expected to fail
3533 return -3;
3534 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003535 // Free the first allocate, retry the second and see success
3536 (*pAlloc)(pAllocCtx, Allocated.ptr, 0); // Free
3537 Allocated = (*pAlloc)(pAllocCtx, NULL, uAvailPool/2);
Laurence Lundbladef6531662018-12-04 10:42:22 +09003538 if(UsefulBuf_IsNULL(Allocated)) { // succeed because of the free
3539 return -4;
3540 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003541
Laurence Lundbladef6531662018-12-04 10:42:22 +09003542 // Re do set up for next test that involves a successful alloc,
3543 // and a successful realloc and a failed realloc
3544 QCBORDecode_SetMemPool(&DC, Pool, 0);
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003545 pAlloc = DC.StringAllocator.pfAllocator;
3546 pAllocCtx = DC.StringAllocator.pAllocateCxt;
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003547
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003548 // Allocate half the pool and see success
3549 Allocated = (*pAlloc)(pAllocCtx, NULL, uAvailPool/2);
Laurence Lundbladef6531662018-12-04 10:42:22 +09003550 if(UsefulBuf_IsNULL(Allocated)) { // expected to succeed
3551 return -5;
3552 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003553 // Reallocate to take up the whole pool and see success
3554 Allocated2 = (*pAlloc)(pAllocCtx, Allocated.ptr, uAvailPool);
Laurence Lundbladef6531662018-12-04 10:42:22 +09003555 if(UsefulBuf_IsNULL(Allocated2)) {
3556 return -6;
3557 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003558 // Make sure its the same pointer and the size is right
Laurence Lundbladef6531662018-12-04 10:42:22 +09003559 if(Allocated2.ptr != Allocated.ptr || Allocated2.len != uAvailPool) {
3560 return -7;
3561 }
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003562 // Try to allocate more to be sure there is failure after a realloc
3563 UsefulBuf Allocated3 = (*pAlloc)(pAllocCtx, Allocated.ptr, uAvailPool+1);
3564 if(!UsefulBuf_IsNULL(Allocated3)) {
Laurence Lundbladef6531662018-12-04 10:42:22 +09003565 return -8;
3566 }
Laurence Lundblade3aee3a32018-12-17 16:17:45 -08003567
Laurence Lundbladef6531662018-12-04 10:42:22 +09003568 return 0;
3569}
Laurence Lundblade2ded3d92018-10-09 21:36:11 +08003570
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003571
3572/* Just enough of an allocator to test configuration of one */
3573static UsefulBuf AllocateTestFunction(void *pCtx, void *pOldMem, size_t uNewSize)
3574{
3575 (void)pOldMem; // unused variable
3576
3577 if(uNewSize) {
3578 // Assumes the context pointer is the buffer and
3579 // nothing too big will ever be asked for.
3580 // This is only good for this basic test!
3581 return (UsefulBuf) {pCtx, uNewSize};
3582 } else {
3583 return NULLUsefulBuf;
3584 }
3585}
3586
3587
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003588int32_t SetUpAllocatorTest(void)
Laurence Lundblade1d7eb632019-02-17 17:23:38 -08003589{
3590 // Set up the decoder with a tiny bit of CBOR to parse because
3591 // nothing can be done with it unless that is set up.
3592 QCBORDecodeContext DC;
3593 const uint8_t pMinimalCBOR[] = {0x62, 0x48, 0x69}; // "Hi"
3594 QCBORDecode_Init(&DC, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pMinimalCBOR),0);
3595
3596 uint8_t pAllocatorBuffer[50];
3597
3598 // This is really just to test that this call works.
3599 // The full functionality of string allocators is tested
3600 // elsewhere with the MemPool internal allocator.
3601 QCBORDecode_SetUpAllocator(&DC, AllocateTestFunction, pAllocatorBuffer, 1);
3602
3603 QCBORItem Item;
3604 if(QCBORDecode_GetNext(&DC, &Item) != QCBOR_SUCCESS) {
3605 return -1;
3606 }
3607
3608 if(Item.uDataAlloc == 0 ||
3609 Item.uDataType != QCBOR_TYPE_TEXT_STRING ||
3610 Item.val.string.ptr != pAllocatorBuffer) {
3611 return -2;
3612 }
3613
3614 if(QCBORDecode_Finish(&DC) != QCBOR_SUCCESS) {
3615 return -3;
3616 }
3617
3618 return 0;
3619}
3620
Laurence Lundblade59289e52019-12-30 13:44:37 -08003621
Laurence Lundbladea826c502020-05-10 21:07:00 -07003622/* exponent, mantissa
Laurence Lundblade59289e52019-12-30 13:44:37 -08003623 [
3624 4([-1, 3]),
Laurence Lundbladea826c502020-05-10 21:07:00 -07003625 4([-20, 4759477275222530853136]),
3626 4([9223372036854775807, -4759477275222530853137]),
Laurence Lundblade59289e52019-12-30 13:44:37 -08003627 5([300, 100]),
Laurence Lundbladea826c502020-05-10 21:07:00 -07003628 5([-20, 4759477275222530853136]),
Laurence Lundblade59289e52019-12-30 13:44:37 -08003629 5([-9223372036854775807, -4759477275222530853137])
Laurence Lundbladea826c502020-05-10 21:07:00 -07003630 5([ 9223372036854775806, -4759477275222530853137])
3631 5([ 9223372036854775806, 9223372036854775806])]
Laurence Lundblade59289e52019-12-30 13:44:37 -08003632 ]
3633 */
3634
3635static const uint8_t spExpectedExponentsAndMantissas[] = {
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003636 0x88,
Laurence Lundblade59289e52019-12-30 13:44:37 -08003637 0xC4, 0x82, 0x20,
3638 0x03,
3639 0xC4, 0x82, 0x33,
3640 0xC2, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10,
3641 0xC4, 0x82, 0x1B, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
3642 0xC3, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10,
3643 0xC5, 0x82, 0x19, 0x01, 0x2C,
3644 0x18, 0x64,
3645 0xC5, 0x82, 0x33,
3646 0xC2, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10,
3647 0xC5, 0x82, 0x3B, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
3648 0xC3, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10,
Laurence Lundbladea826c502020-05-10 21:07:00 -07003649 0xC5, 0x82, 0x1B, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
3650 0xC3, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10,
Laurence Lundblade59289e52019-12-30 13:44:37 -08003651 0xC5, 0x82, 0x1B, 0x7f, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
3652 0x1B, 0x7f, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE
3653};
3654
Laurence Lundbladefaec39f2020-08-02 21:53:53 -07003655#ifndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA
3656
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003657int32_t ExponentAndMantissaDecodeTests(void)
Laurence Lundblade59289e52019-12-30 13:44:37 -08003658{
3659 QCBORDecodeContext DC;
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003660 QCBORError uErr;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003661 QCBORItem item;
3662
Laurence Lundblade17af4902020-01-07 19:11:55 -08003663 static const uint8_t spBigNumMantissa[] = {0x01, 0x02, 0x03, 0x04, 0x05,
3664 0x06, 0x07, 0x08, 0x09, 0x010};
3665 UsefulBufC BN = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spBigNumMantissa);
Laurence Lundblade59289e52019-12-30 13:44:37 -08003666
3667
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003668 QCBORDecode_Init(&DC,
3669 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas),
3670 QCBOR_DECODE_MODE_NORMAL);
Laurence Lundblade59289e52019-12-30 13:44:37 -08003671
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003672 uErr = QCBORDecode_GetNext(&DC, &item);
3673 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08003674 return 1;
3675 }
3676
3677 if(item.uDataType != QCBOR_TYPE_ARRAY) {
3678 return 2;
3679 }
3680
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003681 uErr = QCBORDecode_GetNext(&DC, &item);
3682 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08003683 return 3;
3684 }
3685
3686 if(item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION ||
3687 item.val.expAndMantissa.Mantissa.nInt != 3 ||
3688 item.val.expAndMantissa.nExponent != -1) {
3689 return 4;
3690 }
3691
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003692 uErr = QCBORDecode_GetNext(&DC, &item);
3693 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08003694 return 5;
3695 }
3696
3697 if(item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM ||
3698 item.val.expAndMantissa.nExponent != -20 ||
3699 UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
3700 return 6;
3701 }
3702
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003703 uErr = QCBORDecode_GetNext(&DC, &item);
3704 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08003705 return 7;
3706 }
3707
3708 if(item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION_NEG_BIGNUM ||
3709 item.val.expAndMantissa.nExponent != 9223372036854775807 ||
3710 UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
3711 return 8;
3712 }
3713
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003714 uErr = QCBORDecode_GetNext(&DC, &item);
3715 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08003716 return 9;
3717 }
3718
3719 if(item.uDataType != QCBOR_TYPE_BIGFLOAT ||
3720 item.val.expAndMantissa.Mantissa.nInt != 100 ||
3721 item.val.expAndMantissa.nExponent != 300) {
3722 return 10;
3723 }
3724
Laurence Lundbladea826c502020-05-10 21:07:00 -07003725 // 5([-20, 4759477275222530853136]),
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003726 uErr = QCBORDecode_GetNext(&DC, &item);
3727 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08003728 return 11;
3729 }
Laurence Lundblade59289e52019-12-30 13:44:37 -08003730 if(item.uDataType != QCBOR_TYPE_BIGFLOAT_POS_BIGNUM ||
3731 item.val.expAndMantissa.nExponent != -20 ||
3732 UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
3733 return 12;
3734 }
3735
Laurence Lundbladea826c502020-05-10 21:07:00 -07003736 // 5([-9223372036854775807, -4759477275222530853137])
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003737 uErr = QCBORDecode_GetNext(&DC, &item);
3738 if(uErr != QCBOR_SUCCESS) {
Laurence Lundblade59289e52019-12-30 13:44:37 -08003739 return 13;
3740 }
Laurence Lundblade59289e52019-12-30 13:44:37 -08003741 if(item.uDataType != QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM ||
3742 item.val.expAndMantissa.nExponent != -9223372036854775807 ||
3743 UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
3744 return 14;
3745 }
3746
Laurence Lundbladea826c502020-05-10 21:07:00 -07003747 // 5([ 9223372036854775806, -4759477275222530853137])
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003748 uErr = QCBORDecode_GetNext(&DC, &item);
3749 if(uErr != QCBOR_SUCCESS) {
3750 return 15;
Laurence Lundbladea826c502020-05-10 21:07:00 -07003751 }
3752 if(item.uDataType != QCBOR_TYPE_BIGFLOAT_NEG_BIGNUM ||
3753 item.val.expAndMantissa.nExponent != 9223372036854775806 ||
3754 UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003755 return 16;
Laurence Lundbladea826c502020-05-10 21:07:00 -07003756 }
3757
Laurence Lundbladea826c502020-05-10 21:07:00 -07003758 // 5([ 9223372036854775806, 9223372036854775806])]
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003759 uErr = QCBORDecode_GetNext(&DC, &item);
3760 if(uErr != QCBOR_SUCCESS) {
3761 return 17;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003762 }
Laurence Lundblade59289e52019-12-30 13:44:37 -08003763 if(item.uDataType != QCBOR_TYPE_BIGFLOAT ||
3764 item.val.expAndMantissa.nExponent != 9223372036854775806 ||
3765 item.val.expAndMantissa.Mantissa.nInt!= 9223372036854775806 ) {
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003766 return 18;
3767 }
3768
3769 uErr = QCBORDecode_Finish(&DC);
3770 if(uErr != QCBOR_SUCCESS) {
3771 return 18;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003772 }
3773
3774 /* Now encode some stuff and then decode it */
3775 uint8_t pBuf[40];
3776 QCBOREncodeContext EC;
3777 UsefulBufC Encoded;
3778
3779 QCBOREncode_Init(&EC, UsefulBuf_FROM_BYTE_ARRAY(pBuf));
3780 QCBOREncode_OpenArray(&EC);
3781 QCBOREncode_AddDecimalFraction(&EC, 999, 1000); // 999 * (10 ^ 1000)
3782 QCBOREncode_AddBigFloat(&EC, 100, INT32_MIN);
3783 QCBOREncode_AddDecimalFractionBigNum(&EC, BN, false, INT32_MAX);
3784 QCBOREncode_CloseArray(&EC);
3785 QCBOREncode_Finish(&EC, &Encoded);
3786
3787
3788 QCBORDecode_Init(&DC, Encoded, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003789 uErr = QCBORDecode_GetNext(&DC, &item);
3790 if(uErr != QCBOR_SUCCESS) {
3791 return 100;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003792 }
3793
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003794 uErr = QCBORDecode_GetNext(&DC, &item);
3795 if(uErr != QCBOR_SUCCESS) {
3796 return 101;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003797 }
3798
3799 if(item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION ||
3800 item.val.expAndMantissa.nExponent != 1000 ||
3801 item.val.expAndMantissa.Mantissa.nInt != 999) {
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003802 return 102;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003803 }
3804
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003805 uErr = QCBORDecode_GetNext(&DC, &item);
3806 if(uErr != QCBOR_SUCCESS) {
3807 return 103;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003808 }
3809
3810 if(item.uDataType != QCBOR_TYPE_BIGFLOAT ||
3811 item.val.expAndMantissa.nExponent != INT32_MIN ||
3812 item.val.expAndMantissa.Mantissa.nInt != 100) {
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003813 return 104;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003814 }
3815
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003816 uErr = QCBORDecode_GetNext(&DC, &item);
3817 if(uErr != QCBOR_SUCCESS) {
3818 return 105;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003819 }
3820
3821 if(item.uDataType != QCBOR_TYPE_DECIMAL_FRACTION_POS_BIGNUM ||
3822 item.val.expAndMantissa.nExponent != INT32_MAX ||
3823 UsefulBuf_Compare(item.val.expAndMantissa.Mantissa.bigNum, BN)) {
Laurence Lundbladeb3683da2020-08-02 17:44:54 -07003824 return 106;
3825 }
3826
3827
3828 int64_t nExp, nMant;
3829 UsefulBuf_MAKE_STACK_UB( MantBuf, 20);
3830 UsefulBufC Mant;
3831 bool bIsNeg;
3832
3833 QCBORDecode_Init(&DC,
3834 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas),
3835 QCBOR_DECODE_MODE_NORMAL);
3836 QCBORDecode_EnterArray(&DC);
3837
3838 // 4([-1, 3]),
3839 QCBORDecode_GetDecimalFraction(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &nExp, &nMant);
3840
3841 // 4([-20, 4759477275222530853136]),
3842 QCBORDecode_GetDecimalFractionBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
3843
3844 // 4([9223372036854775807, -4759477275222530853137]),
3845 QCBORDecode_GetDecimalFractionBig(&DC, QCBOR_TAG_REQUIREMENT_OPTIONAL_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
3846
3847 // 5([300, 100]),
3848 QCBORDecode_GetBigFloat(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &nExp, &nMant);
3849
3850 // 5([-20, 4759477275222530853136]),
3851 QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
3852
3853 // 5([-9223372036854775807, -4759477275222530853137])
3854 QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
3855
3856 // 5([ 9223372036854775806, -4759477275222530853137])
3857 QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
3858
3859 // 5([ 9223372036854775806, 9223372036854775806])]
3860 QCBORDecode_GetBigFloatBig(&DC, QCBOR_TAG_REQUIREMENT_MATCH_TAG, MantBuf, &Mant, &bIsNeg, &nExp);
3861
3862 QCBORDecode_ExitArray(&DC);
3863
3864 uErr = QCBORDecode_Finish(&DC);
3865 if(uErr != QCBOR_SUCCESS) {
3866 return 200;
Laurence Lundblade59289e52019-12-30 13:44:37 -08003867 }
3868
3869 return 0;
3870}
3871
3872
3873static struct FailInput ExponentAndMantissaFailures[] = {
3874 // Exponent > INT64_MAX
3875 { {(uint8_t[]){0xC4, 0x82, 0x1B, 0x7f, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
3876 0xFF, 0xFF, 0x1B, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
3877 0xFF, 0xFF,}, 20}, QCBOR_ERR_BAD_EXP_AND_MANTISSA},
3878 // Mantissa > INT64_MAX
3879 { {(uint8_t[]){0xC4, 0x82, 0x1B, 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
3880 0xFF, 0xFF, 0xC3, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05,
3881 0x06, 0x07, 0x08, 0x09, 0x10}, 23}, QCBOR_ERR_BAD_EXP_AND_MANTISSA},
3882 // End of input
Laurence Lundbladee6f15112020-07-23 18:44:16 -07003883 { {(uint8_t[]){0xC4, 0x82}, 2}, QCBOR_ERR_NO_MORE_ITEMS},
Laurence Lundblade59289e52019-12-30 13:44:37 -08003884 // End of input
Laurence Lundbladee6f15112020-07-23 18:44:16 -07003885 { {(uint8_t[]){0xC4, 0x82, 0x01}, 3}, QCBOR_ERR_NO_MORE_ITEMS},
Laurence Lundblade59289e52019-12-30 13:44:37 -08003886 // bad content for big num
3887 { {(uint8_t[]){0xC4, 0x82, 0x01, 0xc3, 0x01}, 5}, QCBOR_ERR_BAD_OPT_TAG},
3888 // bad content for big num
3889 { {(uint8_t[]){0xC4, 0x82, 0xc2, 0x01, 0x1f}, 5}, QCBOR_ERR_BAD_INT},
3890 // Bad integer for exponent
3891 { {(uint8_t[]){0xC4, 0x82, 0x01, 0x1f}, 4}, QCBOR_ERR_BAD_INT},
3892 // Bad integer for mantissa
3893 { {(uint8_t[]){0xC4, 0x82, 0x1f, 0x01}, 4}, QCBOR_ERR_BAD_INT},
3894 // 3 items in array
3895 { {(uint8_t[]){0xC4, 0x83, 0x03, 0x01, 02}, 5}, QCBOR_ERR_BAD_EXP_AND_MANTISSA},
3896 // unterminated indefinite length array
3897 { {(uint8_t[]){0xC4, 0x9f, 0x03, 0x01, 0x02}, 5}, QCBOR_ERR_BAD_EXP_AND_MANTISSA},
3898 // Empty array
3899 { {(uint8_t[]){0xC4, 0x80}, 2}, QCBOR_ERR_NO_MORE_ITEMS},
3900 // Second is not an integer
3901 { {(uint8_t[]){0xC4, 0x82, 0x03, 0x40}, 4}, QCBOR_ERR_BAD_EXP_AND_MANTISSA},
3902 // First is not an integer
3903 { {(uint8_t[]){0xC4, 0x82, 0x40}, 3}, QCBOR_ERR_BAD_EXP_AND_MANTISSA},
3904 // Not an array
3905 { {(uint8_t[]){0xC4, 0xa2}, 2}, QCBOR_ERR_BAD_EXP_AND_MANTISSA}
3906};
3907
3908
Laurence Lundbladec5fef682020-01-25 11:38:45 -08003909int32_t ExponentAndMantissaDecodeFailTests()
Laurence Lundblade59289e52019-12-30 13:44:37 -08003910{
3911 return ProcessFailures(ExponentAndMantissaFailures,
3912 sizeof(ExponentAndMantissaFailures)/sizeof(struct FailInput));
3913}
3914
3915#endif /* QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003916
3917
3918
3919/*
3920 Some basic CBOR with map and array used in a lot of tests.
3921 The map labels are all strings
3922
Laurence Lundblade8ffdb742020-05-07 02:49:18 -07003923 {
3924 "first integer": 42,
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003925 "an array of two strings": [
3926 "string1", "string2"
3927 ],
3928 "map in a map": {
3929 "bytes 1": h'78787878',
3930 "bytes 2": h'79797979',
3931 "another int": 98,
3932 "text 2": "lies, damn lies and statistics"
3933 }
3934 }
3935 */
3936
Laurence Lundblade1341c592020-04-11 14:19:05 -07003937#include <stdio.h>
Laurence Lundbladebb87be22020-04-09 19:15:32 -07003938
Laurence Lundblade9c905e82020-04-25 11:31:38 -07003939static char strbuf[10];
3940const char *PrintType(uint8_t type) {
3941 switch(type) {
3942 case QCBOR_TYPE_INT64: return "INT64";
3943 case QCBOR_TYPE_UINT64: return "UINT64";
3944 case QCBOR_TYPE_ARRAY: return "ARRAY";
3945 case QCBOR_TYPE_MAP: return "MAP";
3946 case QCBOR_TYPE_BYTE_STRING: return "BYTE_STRING";
3947 case QCBOR_TYPE_TEXT_STRING: return "TEXT_STRING";
3948 default:
3949 sprintf(strbuf, "%d", type);
3950 return strbuf;
3951 }
3952}
3953
3954
3955void PrintItem(QCBORItem Item)
3956{
3957 printf("\nData: %s nest: %d,%d %s\n", PrintType(Item.uDataType), Item.uNestingLevel, Item.uNextNestLevel, Item.uDataAlloc ? "Allocated":"");
3958 if(Item.uLabelType) {
3959 printf("Label: %s ", PrintType(Item.uLabelType));
3960 if(Item.uLabelType == QCBOR_TYPE_INT64) {
3961 printf("%lld\n", Item.label.int64);
3962 } else if(Item.uLabelType == QCBOR_TYPE_TEXT_STRING) {
Laurence Lundblade40a04322020-06-27 22:52:52 -07003963 // TODO: proper conversion to null-terminated string
3964 printf("\"%4.4s\"\n", (const char *)Item.label.string.ptr);
Laurence Lundblade9c905e82020-04-25 11:31:38 -07003965 }
3966 }
3967}
3968
Laurence Lundblade8ffdb742020-05-07 02:49:18 -07003969
Laurence Lundblade2c1faf92020-06-26 22:43:56 -07003970int32_t EMap(UsefulBufC input)
3971{
3972 QCBORItem Item1, Item2, Item3;
3973 int64_t nDecodedInt1, nDecodedInt2;
3974 UsefulBufC B1, B2, S1, S2, S3;
3975
3976 QCBORDecodeContext DCtx;
3977 QCBORError nCBORError;
3978
3979 QCBORDecode_Init(&DCtx, input, 0);
3980
3981 QCBORDecode_EnterMap(&DCtx);
3982
3983 QCBORDecode_GetInt64InMapSZ(&DCtx, "first integer", &nDecodedInt1);
3984
3985 QCBORDecode_EnterMapFromMapSZ(&DCtx, "map in a map");
3986 QCBORDecode_GetInt64InMapSZ(&DCtx, "another int", &nDecodedInt2);
3987 QCBORDecode_GetBytesInMapSZ(&DCtx, "bytes 1", &B1);
3988 QCBORDecode_GetBytesInMapSZ(&DCtx, "bytes 2", &B2);
3989 QCBORDecode_GetTextInMapSZ(&DCtx, "text 2", &S1);
3990 QCBORDecode_ExitMap(&DCtx);
3991
3992 QCBORDecode_EnterArrayFromMapSZ(&DCtx, "an array of two strings");
3993 QCBORDecode_GetNext(&DCtx, &Item1);
3994 QCBORDecode_GetNext(&DCtx, &Item2);
3995 if(QCBORDecode_GetNext(&DCtx, &Item3) != QCBOR_ERR_NO_MORE_ITEMS) {
3996 return -400;
3997 }
3998 QCBORDecode_ExitArray(&DCtx);
3999
4000 // Parse the same array again using GetText() instead of GetItem()
4001 QCBORDecode_EnterArrayFromMapSZ(&DCtx, "an array of two strings");
4002 QCBORDecode_GetText(&DCtx, &S2);
4003 QCBORDecode_GetText(&DCtx, &S3);
4004 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS) {
4005 return 5000;
4006 }
4007 /* QCBORDecode_GetText(&DCtx, &S3);
4008 if(QCBORDecode_GetAndResetError(&DCtx) != QCBOR_ERR_NO_MORE_ITEMS) {
4009 return 5001;
4010 } */
4011
4012 QCBORDecode_ExitArray(&DCtx);
4013
4014 QCBORDecode_ExitMap(&DCtx);
4015
4016 nCBORError = QCBORDecode_Finish(&DCtx);
4017
4018 if(nCBORError) {
4019 return (int32_t)nCBORError;
4020 }
4021
4022 if(nDecodedInt1 != 42) {
4023 return 1001;
4024 }
4025
4026 if(nDecodedInt2 != 98) {
4027 return 1002;
4028 }
4029
4030 if(Item1.uDataType != QCBOR_TYPE_TEXT_STRING ||
4031 UsefulBuf_Compare(Item1.val.string, UsefulBuf_FromSZ("string1"))){
4032 return 1003;
4033 }
4034
4035 if(Item1.uDataType != QCBOR_TYPE_TEXT_STRING ||
4036 UsefulBuf_Compare(Item2.val.string, UsefulBuf_FromSZ("string2"))){
4037 return 1004;
4038 }
4039
4040 if(UsefulBuf_Compare(S1, UsefulBuf_FromSZ("lies, damn lies and statistics"))){
4041 return 1005;
4042 }
4043
4044 if(UsefulBuf_Compare(B1, UsefulBuf_FromSZ("xxxx"))){
4045 return 1006;
4046 }
4047
4048 if(UsefulBuf_Compare(B2, UsefulBuf_FromSZ("yyyy"))){
4049 return 1007;
4050 }
4051
4052 if(UsefulBuf_Compare(S2, UsefulBuf_FromSZ("string1"))){
4053 return 1008;
4054 }
4055
4056 if(UsefulBuf_Compare(S3, UsefulBuf_FromSZ("string2"))){
4057 return 1009;
4058 }
4059
4060 return 0;
4061}
4062
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004063
4064/*
4065 [23,
4066 6000,
4067 h'67616C6163746963',
4068 h'686176656E20746F6B656E'
4069 ]
4070 */
4071static const uint8_t spSimpleArray[] = {
40720x84, 0x17, 0x19, 0x17, 0x70, 0x48, 0x67, 0x61, 0x6C, 0x61, 0x63, 0x74, 0x69, 0x63, 0x4B, 0x68, 0x61, 0x76, 0x65, 0x6E, 0x20, 0x74, 0x6F, 0x6B, 0x65, 0x6E};
4073
4074
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004075static const uint8_t spEmptyMap[] = {0xa0};
4076
4077static const uint8_t spEmptyInDefinteLengthMap[] = {0xbf, 0xff};
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004078
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07004079static const uint8_t spArrayOfEmpty[] = {0x84, 0x40, 0xa0, 0x80, 0x00};
4080
Laurence Lundbladef0499502020-08-01 11:55:57 -07004081/*
4082 {
4083 0: [],
4084 9: [
4085 [],
4086 []
4087 ],
4088 8: {
4089 1: [],
4090 2: {},
4091 3: []
4092 },
4093 4: {},
4094 5: [],
4095 6: [
4096 [],
4097 []
4098 ]
4099 }
4100 */
4101static const uint8_t spMapOfEmpty[] = {
4102 0xa6, 0x00, 0x80, 0x09, 0x82, 0x80, 0x80, 0x08, 0xa3, 0x01,
4103 0x80, 0x02, 0xa0, 0x03, 0x80, 0x04, 0xa0, 0x05, 0x9f, 0xff,
4104 0x06, 0x9f, 0x80, 0x9f, 0xff, 0xff};
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004105
Laurence Lundbladebb87be22020-04-09 19:15:32 -07004106int32_t EnterMapTest()
4107{
Laurence Lundbladef0499502020-08-01 11:55:57 -07004108 QCBORItem Item1;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07004109 QCBORDecodeContext DCtx;
Laurence Lundbladef0499502020-08-01 11:55:57 -07004110 int32_t nReturn;
4111 QCBORError uErr;
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004112
4113
4114 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spMapOfEmpty), 0);
4115 QCBORDecode_EnterMap(&DCtx);
4116
Laurence Lundbladef0499502020-08-01 11:55:57 -07004117
4118 QCBORDecode_EnterArray(&DCtx); // Label 0
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004119 QCBORDecode_ExitArray(&DCtx);
4120
Laurence Lundbladef0499502020-08-01 11:55:57 -07004121 QCBORDecode_EnterArray(&DCtx); // Label 9
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004122 QCBORDecode_EnterArray(&DCtx);
4123 QCBORDecode_ExitArray(&DCtx);
4124 QCBORDecode_EnterArray(&DCtx);
4125 QCBORDecode_ExitArray(&DCtx);
4126 QCBORDecode_ExitArray(&DCtx);
4127
Laurence Lundbladef0499502020-08-01 11:55:57 -07004128 QCBORDecode_EnterMap(&DCtx); // Label 8
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004129 QCBORDecode_EnterArray(&DCtx);
4130 QCBORDecode_ExitArray(&DCtx);
4131 QCBORDecode_EnterMap(&DCtx);
4132 QCBORDecode_ExitMap(&DCtx);
4133 QCBORDecode_EnterArray(&DCtx);
4134 QCBORDecode_ExitArray(&DCtx);
4135 QCBORDecode_ExitMap(&DCtx);
4136
Laurence Lundbladef0499502020-08-01 11:55:57 -07004137 QCBORDecode_EnterMap(&DCtx); // Label4
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004138 QCBORDecode_ExitMap(&DCtx);
4139
Laurence Lundbladef0499502020-08-01 11:55:57 -07004140 QCBORDecode_EnterArray(&DCtx); // Label 5
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004141 QCBORDecode_ExitArray(&DCtx);
4142
Laurence Lundbladef0499502020-08-01 11:55:57 -07004143 QCBORDecode_EnterArray(&DCtx); // Label 6
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004144 QCBORDecode_EnterArray(&DCtx);
4145 QCBORDecode_ExitArray(&DCtx);
4146 QCBORDecode_EnterArray(&DCtx);
4147 QCBORDecode_ExitArray(&DCtx);
4148 QCBORDecode_ExitArray(&DCtx);
4149
4150 QCBORDecode_ExitMap(&DCtx);
4151
4152 uErr = QCBORDecode_Finish(&DCtx);
4153 if(uErr != QCBOR_SUCCESS){
4154 return 3011;
4155 }
4156
4157
Laurence Lundblade2c1faf92020-06-26 22:43:56 -07004158 (void)pValidMapIndefEncoded;
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004159 nReturn = EMap(UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapIndefEncoded));
Laurence Lundblade2c1faf92020-06-26 22:43:56 -07004160 if(nReturn) {
4161 return nReturn + 20000;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07004162 }
4163
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004164 nReturn = EMap(UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded));
Laurence Lundblade2c1faf92020-06-26 22:43:56 -07004165 if(nReturn) {
4166 return nReturn;
4167 }
Laurence Lundbladebb87be22020-04-09 19:15:32 -07004168
Laurence Lundblade8ffdb742020-05-07 02:49:18 -07004169
Laurence Lundblade937ea812020-05-08 11:38:23 -07004170
4171 // These tests confirm the cursor is at the right place after entering a map or array
4172
4173 // Confirm cursor is at right place
4174 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
4175 QCBORDecode_EnterMap(&DCtx);
4176 QCBORDecode_GetNext(&DCtx, &Item1);
4177 if(Item1.uDataType != QCBOR_TYPE_INT64) {
4178 return 2001;
4179 }
4180
4181
4182 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
4183 QCBORDecode_GetNext(&DCtx, &Item1);
4184 QCBORDecode_GetNext(&DCtx, &Item1);
4185 QCBORDecode_EnterArray(&DCtx);
4186 QCBORDecode_GetNext(&DCtx, &Item1);
4187 if(Item1.uDataType != QCBOR_TYPE_TEXT_STRING) {
4188 return 2002;
4189 }
4190
4191 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
4192 QCBORDecode_EnterMap(&DCtx);
Laurence Lundblade64b607e2020-05-13 13:05:57 -07004193 QCBORDecode_GetNext(&DCtx, &Item1);
4194 QCBORDecode_GetNext(&DCtx, &Item1);
4195 QCBORDecode_GetNext(&DCtx, &Item1);
Laurence Lundblade937ea812020-05-08 11:38:23 -07004196 QCBORDecode_EnterMapFromMapSZ(&DCtx, "map in a map");
4197 QCBORDecode_GetNext(&DCtx, &Item1);
4198 if(Item1.uDataType != QCBOR_TYPE_BYTE_STRING) {
4199 return 2003;
4200 }
4201
4202 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
4203 QCBORDecode_EnterMap(&DCtx);
4204 QCBORDecode_GetNext(&DCtx, &Item1);
4205 QCBORDecode_GetNext(&DCtx, &Item1);
4206 QCBORDecode_GetNext(&DCtx, &Item1);
4207 QCBORDecode_GetNext(&DCtx, &Item1);
4208 QCBORDecode_GetNext(&DCtx, &Item1);
4209 QCBORDecode_GetNext(&DCtx, &Item1);
4210 QCBORDecode_GetNext(&DCtx, &Item1);
4211 QCBORDecode_EnterArrayFromMapSZ(&DCtx, "an array of two strings");
4212 QCBORDecode_GetNext(&DCtx, &Item1);
4213 if(Item1.uDataType != QCBOR_TYPE_TEXT_STRING) {
Laurence Lundblade64b607e2020-05-13 13:05:57 -07004214 return 2004;
Laurence Lundblade937ea812020-05-08 11:38:23 -07004215 }
4216
Laurence Lundblade2b843b52020-06-16 20:51:03 -07004217 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(pValidMapEncoded), 0);
4218 QCBORDecode_EnterMap(&DCtx);
4219 QCBORDecode_EnterArrayFromMapSZ(&DCtx, "an array of two strings");
4220 QCBORDecode_ExitArray(&DCtx);
4221 QCBORDecode_GetNext(&DCtx, &Item1);
4222 if(Item1.uDataType != QCBOR_TYPE_MAP && Item1.uLabelAlloc != QCBOR_TYPE_TEXT_STRING) {
4223 return 2006;
4224 }
4225 QCBORDecode_ExitMap(&DCtx);
4226 if(QCBORDecode_GetNext(&DCtx, &Item1) != QCBOR_ERR_NO_MORE_ITEMS) {
4227 return 2007;
4228 }
4229
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004230 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spSimpleArray), 0);
4231 QCBORDecode_EnterArray(&DCtx);
4232 int64_t nDecodedInt2;
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004233 QCBORDecode_GetInt64InMapSZ(&DCtx, "another int", &nDecodedInt2);
4234 uErr = QCBORDecode_GetAndResetError(&DCtx);
4235 if(uErr != QCBOR_ERR_MAP_NOT_ENTERED){
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004236 return 2008;
4237 }
4238 UsefulBufC String;
4239 QCBORDecode_GetTextInMapN(&DCtx, 88, &String);
Laurence Lundblade2cd4b0d2020-07-31 08:29:07 -07004240 if(uErr != QCBOR_ERR_MAP_NOT_ENTERED){
Laurence Lundbladeabf5c572020-06-29 21:21:29 -07004241 return 2009;
4242 }
Laurence Lundblade937ea812020-05-08 11:38:23 -07004243
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004244
4245 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spEmptyMap), 0);
4246 QCBORDecode_EnterMap(&DCtx);
4247 // This will fail because the map is empty.
4248 QCBORDecode_GetInt64InMapSZ(&DCtx, "another int", &nDecodedInt2);
4249 uErr = QCBORDecode_GetAndResetError(&DCtx);
4250 if(uErr != QCBOR_ERR_NOT_FOUND){
4251 return 2010;
4252 }
4253 QCBORDecode_ExitMap(&DCtx);
4254 uErr = QCBORDecode_Finish(&DCtx);
4255 if(uErr != QCBOR_SUCCESS){
4256 return 2011;
4257 }
4258
4259
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004260 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spEmptyInDefinteLengthMap), 0);
4261 QCBORDecode_EnterMap(&DCtx);
4262 // This will fail because the map is empty.
4263 QCBORDecode_GetInt64InMapSZ(&DCtx, "another int", &nDecodedInt2);
4264 uErr = QCBORDecode_GetAndResetError(&DCtx);
4265 if(uErr != QCBOR_ERR_NOT_FOUND){
Laurence Lundblade085d7952020-07-24 10:26:30 -07004266 return 2012;
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004267 }
4268 QCBORDecode_ExitMap(&DCtx);
4269 uErr = QCBORDecode_Finish(&DCtx);
4270 if(uErr != QCBOR_SUCCESS){
Laurence Lundblade085d7952020-07-24 10:26:30 -07004271 return 2013;
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004272 }
4273
Laurence Lundblade5f4e8712020-07-25 11:44:43 -07004274
4275 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spArrayOfEmpty), 0);
4276 QCBORDecode_EnterArray(&DCtx);
4277 QCBORDecode_GetBytes(&DCtx, &String);
4278 QCBORDecode_EnterMap(&DCtx);
4279 QCBORDecode_ExitMap(&DCtx);
4280 QCBORDecode_EnterArray(&DCtx);
4281 QCBORDecode_ExitArray(&DCtx);
4282 QCBORDecode_GetInt64(&DCtx, &nDecodedInt2);
4283 QCBORDecode_ExitArray(&DCtx);
4284 uErr = QCBORDecode_Finish(&DCtx);
4285 if(uErr != QCBOR_SUCCESS){
4286 return 2014;
4287 }
4288
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07004289 // TODO: more testing of entered mapps and arrays with problems
4290 // TODO: document error handling better (maybe improve error handling)
4291
Laurence Lundbladee6f15112020-07-23 18:44:16 -07004292 return 0;
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004293}
4294
4295
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004296struct NumberConversion {
4297 char *szDescription;
4298 UsefulBufC CBOR;
4299 int64_t nConvertedToInt64;
4300 QCBORError uErrorInt64;
4301 uint64_t uConvertToUInt64;
4302 QCBORError uErrorUint64;
4303 double dConvertToDouble;
4304 QCBORError uErrorDouble;
4305};
4306
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004307static const struct NumberConversion NumberConversions[] = {
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004308 {
Laurence Lundbladeda095972020-06-06 18:35:33 -07004309 "negative bignum -1",
4310 {(uint8_t[]){0xc3, 0x41, 0x00}, 3},
4311 -1,
4312 QCBOR_SUCCESS,
4313 0,
4314 QCBOR_ERR_NUMBER_SIGN_CONVERSION,
4315 -1.0,
4316 QCBOR_SUCCESS
4317 },
4318 {
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004319 "Decimal Fraction with positive bignum 257 * 10e3",
Laurence Lundblade887add82020-05-17 05:50:34 -07004320 {(uint8_t[]){0xC4, 0x82, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
4321 0xC2, 0x42, 0x01, 0x01}, 15},
4322 257000,
4323 QCBOR_SUCCESS,
4324 257000,
4325 QCBOR_SUCCESS,
4326 257000.0,
4327 QCBOR_SUCCESS
4328 },
4329 {
Laurence Lundbladeda095972020-06-06 18:35:33 -07004330 "bigfloat with negative bignum -258 * 2e3",
Laurence Lundblade887add82020-05-17 05:50:34 -07004331 {(uint8_t[]){0xC5, 0x82, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
4332 0xC3, 0x42, 0x01, 0x01}, 15},
Laurence Lundbladeda095972020-06-06 18:35:33 -07004333 -2064,
Laurence Lundblade887add82020-05-17 05:50:34 -07004334 QCBOR_SUCCESS,
4335 0,
4336 QCBOR_ERR_NUMBER_SIGN_CONVERSION,
Laurence Lundbladeda095972020-06-06 18:35:33 -07004337 -2064.0,
Laurence Lundblade887add82020-05-17 05:50:34 -07004338 QCBOR_SUCCESS
4339 },
4340 {
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004341 "bigfloat with positive bignum 257 * 2e3",
Laurence Lundblade887add82020-05-17 05:50:34 -07004342 {(uint8_t[]){0xC5, 0x82, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03,
4343 0xC2, 0x42, 0x01, 0x01}, 15},
4344 2056,
4345 QCBOR_SUCCESS,
4346 2056,
4347 QCBOR_SUCCESS,
4348 2056.0,
4349 QCBOR_SUCCESS
4350 },
4351 {
Laurence Lundbladeda095972020-06-06 18:35:33 -07004352 "negative bignum 0xc349010000000000000000 -18446744073709551617",
Laurence Lundblade887add82020-05-17 05:50:34 -07004353 {(uint8_t[]){0xc3, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 11},
4354 0,
4355 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4356 0,
4357 QCBOR_ERR_NUMBER_SIGN_CONVERSION,
4358 -18446744073709551617.0,
4359 QCBOR_SUCCESS
4360 },
4361 {
Laurence Lundblade313b2862020-05-16 01:23:06 -07004362 "Positive bignum 0x01020304 indefinite length string",
4363 {(uint8_t[]){0xC2, 0x5f, 0x42, 0x01, 0x02, 0x41, 0x03, 0x41, 0x04, 0xff}, 10},
4364 0x01020304,
4365 QCBOR_SUCCESS,
4366 0x01020304,
4367 QCBOR_SUCCESS,
4368 16909060.0,
4369 QCBOR_SUCCESS
4370 },
4371 {
Laurence Lundblade887add82020-05-17 05:50:34 -07004372 "Decimal Fraction with neg bignum [9223372036854775807, -4759477275222530853137]",
Laurence Lundblade313b2862020-05-16 01:23:06 -07004373 {(uint8_t[]){0xC4, 0x82, 0x1B, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
4374 0xC3, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10,}, 23},
4375 0,
4376 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4377 0,
4378 QCBOR_ERR_NUMBER_SIGN_CONVERSION,
4379 -INFINITY,
4380 QCBOR_SUCCESS
4381 },
4382 {
4383 "big float [9223372036854775806, 9223372036854775806]",
4384 {(uint8_t[]){0xC5, 0x82, 0x1B, 0x7f, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE,
4385 0x1B, 0x7f, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE}, 20},
4386 0,
4387 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4388 0,
4389 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4390 INFINITY,
4391 QCBOR_SUCCESS
4392 },
4393 {
Laurence Lundblade983500d2020-05-14 11:49:34 -07004394 "Big float 3 * 2^^2",
4395 {(uint8_t[]){0xC5, 0x82, 0x02, 0x03}, 4},
4396 12,
4397 QCBOR_SUCCESS,
4398 12,
4399 QCBOR_SUCCESS,
4400 12.0,
4401 QCBOR_SUCCESS
4402 },
Laurence Lundblade983500d2020-05-14 11:49:34 -07004403 {
Laurence Lundblade313b2862020-05-16 01:23:06 -07004404 "Positive integer 18446744073709551615",
Laurence Lundblade983500d2020-05-14 11:49:34 -07004405 {(uint8_t[]){0x1b, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 9},
4406 0,
4407 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4408 18446744073709551615ULL,
4409 QCBOR_SUCCESS,
4410 18446744073709551615.0,
4411 QCBOR_SUCCESS
4412 },
Laurence Lundblade983500d2020-05-14 11:49:34 -07004413 {
Laurence Lundblade313b2862020-05-16 01:23:06 -07004414 "Positive bignum 0xffff",
Laurence Lundblade983500d2020-05-14 11:49:34 -07004415 {(uint8_t[]){0xC2, 0x42, 0xff, 0xff}, 4},
4416 65536-1,
4417 QCBOR_SUCCESS,
4418 0xffff,
4419 QCBOR_SUCCESS,
4420 65535.0,
4421 QCBOR_SUCCESS
4422 },
4423 {
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004424 "Postive integer 0",
4425 {(uint8_t[]){0x0}, 1},
4426 0LL,
4427 QCBOR_SUCCESS,
4428 0ULL,
4429 QCBOR_SUCCESS,
4430 0.0,
4431 QCBOR_SUCCESS
4432 },
4433 {
Laurence Lundblade313b2862020-05-16 01:23:06 -07004434 "Negative integer -18446744073709551616",
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004435 {(uint8_t[]){0x3b, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, 9},
4436 -9223372036854775807-1, // INT64_MIN
4437 QCBOR_SUCCESS,
4438 0ULL,
4439 QCBOR_ERR_NUMBER_SIGN_CONVERSION,
4440 -9223372036854775808.0,
4441 QCBOR_SUCCESS
4442 },
4443 {
Laurence Lundblade313b2862020-05-16 01:23:06 -07004444 "Double Floating point value 100.3",
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004445 {(uint8_t[]){0xfb, 0x40, 0x59, 0x13, 0x33, 0x33, 0x33, 0x33, 0x33}, 9},
4446 100L,
4447 QCBOR_SUCCESS,
4448 100ULL,
4449 QCBOR_SUCCESS,
4450 100.3,
4451 QCBOR_SUCCESS
4452 },
4453 {
4454 "Floating point value NaN 0xfa7fc00000",
4455 {(uint8_t[]){0xfa, 0x7f, 0xc0, 0x00, 0x00}, 5},
4456 0,
4457 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4458 0,
4459 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4460 NAN,
4461 QCBOR_SUCCESS
4462 },
4463 {
Laurence Lundblade313b2862020-05-16 01:23:06 -07004464 "half-precision Floating point value -4",
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004465 {(uint8_t[]){0xf9, 0xc4, 0x00}, 3},
4466 -4,
4467 QCBOR_SUCCESS,
4468 0,
4469 QCBOR_ERR_NUMBER_SIGN_CONVERSION,
4470 -4.0,
4471 QCBOR_SUCCESS
4472 },
4473 {
4474 "Decimal fraction 3/10",
4475 {(uint8_t[]){0xC4, 0x82, 0x20, 0x03}, 4},
4476 0,
4477 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4478 0,
4479 QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW,
4480 0.30000000000000004,
4481 QCBOR_SUCCESS
4482 }
4483};
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004484
4485
4486
Laurence Lundblade313b2862020-05-16 01:23:06 -07004487int32_t IntegerConvertTest()
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004488{
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004489 const int nNumTests = sizeof(NumberConversions)/sizeof(struct NumberConversion);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004490
Laurence Lundblade9ab5abb2020-05-20 12:10:45 -07004491 for(int nIndex = 0; nIndex < nNumTests; nIndex++) {
4492 const struct NumberConversion *pF = &NumberConversions[nIndex];
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004493
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004494 // Set up the decoding context including a memory pool so that
4495 // indefinite length items can be checked
4496 QCBORDecodeContext DCtx;
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004497 UsefulBuf_MAKE_STACK_UB(Pool, 100);
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004498
4499 /* ----- test conversion to int64_t ------ */
4500 QCBORDecode_Init(&DCtx, pF->CBOR, QCBOR_DECODE_MODE_NORMAL);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004501 QCBORError nCBORError = QCBORDecode_SetMemPool(&DCtx, Pool, 0);
4502 if(nCBORError) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004503 return (int32_t)(1000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004504 }
4505
4506 int64_t nInt;
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004507 QCBORDecode_GetInt64ConvertAll(&DCtx, 0xffff, &nInt);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004508 if(QCBORDecode_GetError(&DCtx) != pF->uErrorInt64) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004509 return (int32_t)(2000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004510 }
4511 if(pF->uErrorInt64 == QCBOR_SUCCESS && pF->nConvertedToInt64 != nInt) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004512 return (int32_t)(3000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004513 }
4514
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004515 /* ----- test conversion to uint64_t ------ */
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004516 QCBORDecode_Init(&DCtx, pF->CBOR, QCBOR_DECODE_MODE_NORMAL);
4517 nCBORError = QCBORDecode_SetMemPool(&DCtx, Pool, 0);
4518 if(nCBORError) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004519 return (int32_t)(1000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004520 }
4521 uint64_t uInt;
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004522 QCBORDecode_GetUInt64ConvertAll(&DCtx, 0xffff, &uInt);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004523 if(QCBORDecode_GetError(&DCtx) != pF->uErrorUint64) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004524 return (int32_t)(4000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004525 }
4526 if(pF->uErrorUint64 == QCBOR_SUCCESS && pF->uConvertToUInt64 != uInt) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004527 return (int32_t)(5000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004528 }
4529
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004530 /* ----- test conversion to double ------ */
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004531 QCBORDecode_Init(&DCtx, pF->CBOR, QCBOR_DECODE_MODE_NORMAL);
4532 nCBORError = QCBORDecode_SetMemPool(&DCtx, Pool, 0);
4533 if(nCBORError) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004534 return (int32_t)(1000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004535 }
4536 double d;
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004537 QCBORDecode_GetDoubleConvertAll(&DCtx, 0xffff, &d);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004538 if(QCBORDecode_GetError(&DCtx) != pF->uErrorDouble) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004539 return (int32_t)(6000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004540 }
4541 if(pF->uErrorDouble == QCBOR_SUCCESS) {
4542 if(isnan(pF->dConvertToDouble)) {
Laurence Lundblade983500d2020-05-14 11:49:34 -07004543 // NaN's can't be compared for equality. A NaN is
4544 // never equal to anything including another NaN
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004545 if(!isnan(d)) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004546 return (int32_t)(7000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004547 }
4548 } else {
4549 // TODO: this comparison may need a margin of error
4550 if(pF->dConvertToDouble != d) {
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004551 return (int32_t)(8000+nIndex);
Laurence Lundbladef6c86662020-05-12 02:08:00 -07004552 }
4553 }
4554 }
4555 }
4556
4557 return 0;
4558}
4559
Laurence Lundblade313b2862020-05-16 01:23:06 -07004560int32_t IntegerConvertTestOld()
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004561{
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004562 QCBORDecodeContext DCtx;
4563 QCBORError nCBORError;
4564
Laurence Lundbladea826c502020-05-10 21:07:00 -07004565 /* exponent, mantissa
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004566 [
4567 4([-1, 3]),
4568 4([-20, 4759477275222530853136]),
4569 4([9223372036854775807, -4759477275222530853137]),
4570 5([300, 100]),
4571 5([-20, 4759477275222530853136]),
4572 5([-9223372036854775807, -4759477275222530853137])
Laurence Lundbladea826c502020-05-10 21:07:00 -07004573 5([ 9223372036854775806, -4759477275222530853137])
4574 5([ 9223372036854775806, 9223372036854775806])]
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004575 ]
4576 */
4577
4578 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas), 0);
4579
4580 QCBORItem Item;
4581 nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4582 if(nCBORError) {
4583 return -1;
4584 }
4585
4586 int64_t integer;
Laurence Lundbladea826c502020-05-10 21:07:00 -07004587 // 4([-1, 3]),
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004588 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004589 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004590 return -2;
4591 }
4592 DCtx.uLastError = 0; // TODO: a method for this
4593
Laurence Lundbladea826c502020-05-10 21:07:00 -07004594 // 4([-20, 4759477275222530853136]),
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004595 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004596 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004597 return -2;
4598 }
4599 DCtx.uLastError = 0; // TODO: a method for this
4600
Laurence Lundbladea826c502020-05-10 21:07:00 -07004601 // 4([9223372036854775807, -4759477275222530853137]),
4602 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004603 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004604 return -2;
4605 }
4606 DCtx.uLastError = 0; // TODO: a method for this
4607
4608 // 5([300, 100]),
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004609 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004610 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004611 return -2;
4612 }
4613 DCtx.uLastError = 0; // TODO: a method for this
4614
Laurence Lundbladea826c502020-05-10 21:07:00 -07004615 // 5([-20, 4759477275222530853136]),
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004616 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004617 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundblade9c905e82020-04-25 11:31:38 -07004618 return -2;
4619 }
4620 DCtx.uLastError = 0; // TODO: a method for this
4621
Laurence Lundbladea826c502020-05-10 21:07:00 -07004622 // 5([-9223372036854775807, -4759477275222530853137])
4623 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004624 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004625 return -2;
4626 }
4627 DCtx.uLastError = 0; // TODO: a method for this
4628
4629 // 5([ 9223372036854775806, -4759477275222530853137])
4630 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004631 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004632 return -2;
4633 }
4634 DCtx.uLastError = 0; // TODO: a method for this
4635
4636 // 5([ 9223372036854775806, 9223372036854775806])]
4637 QCBORDecode_GetInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &integer);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004638 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004639 return -2;
4640 }
4641 DCtx.uLastError = 0; // TODO: a method for this
4642
4643
4644
4645 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas), 0);
4646
4647 nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4648 if(nCBORError) {
4649 return -1;
4650 }
4651
4652 uint64_t uinteger;
4653 // 4([-1, 3]),
4654 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &uinteger);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004655 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004656 return -2;
4657 }
4658 DCtx.uLastError = 0; // TODO: a method for this
4659
4660 // 4([-20, 4759477275222530853136]),
4661 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &uinteger);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004662 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004663 return -2;
4664 }
4665 DCtx.uLastError = 0; // TODO: a method for this
4666
4667 // 4([9223372036854775807, -4759477275222530853137]),
4668 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &uinteger);
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004669 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_NUMBER_SIGN_CONVERSION) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004670 return -2;
4671 }
4672 DCtx.uLastError = 0; // TODO: a method for this
4673
4674 // 5([300, 100]),
4675 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &uinteger);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004676 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004677 return -2;
4678 }
4679 DCtx.uLastError = 0; // TODO: a method for this
4680
4681 // 5([-20, 4759477275222530853136]),
4682 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &uinteger);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004683 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004684 return -2;
4685 }
4686 DCtx.uLastError = 0; // TODO: a method for this
4687
4688 // 5([-9223372036854775807, -4759477275222530853137])
4689 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &uinteger);
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004690 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_NUMBER_SIGN_CONVERSION) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004691 return -2;
4692 }
4693 DCtx.uLastError = 0; // TODO: a method for this
4694
4695 // 5([ 9223372036854775806, -4759477275222530853137])
4696 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &uinteger);
Laurence Lundblade54cd99c2020-05-15 02:25:32 -07004697 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_NUMBER_SIGN_CONVERSION) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004698 return -2;
4699 }
4700 DCtx.uLastError = 0; // TODO: a method for this
4701
4702 // 5([ 9223372036854775806, 9223372036854775806])]
4703 QCBORDecode_GetUInt64ConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION|QCBOR_CONVERT_TYPE_BIGFLOAT, &uinteger);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004704 if(QCBORDecode_GetError(&DCtx) != QCBOR_ERR_CONVERSION_UNDER_OVER_FLOW) {
Laurence Lundbladea826c502020-05-10 21:07:00 -07004705 return -2;
4706 }
4707 DCtx.uLastError = 0; // TODO: a method for this
4708
4709
4710
4711 QCBORDecode_Init(&DCtx, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedExponentsAndMantissas), 0);
4712 nCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4713 if(nCBORError) {
4714 return -1;
4715 }
4716
4717 double dResult;
4718 // 4([-1, 3]),
4719 QCBORDecode_GetDoubleConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &dResult);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004720 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS &&
Laurence Lundbladea826c502020-05-10 21:07:00 -07004721 dResult != 0.3) {
4722 return -2;
4723 }
4724
4725 // 4([-20, 4759477275222530853136]),
4726 QCBORDecode_GetDoubleConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &dResult);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004727 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS &&
Laurence Lundbladea826c502020-05-10 21:07:00 -07004728 dResult != 47.408855671161923) {
4729 return -2;
4730 }
4731
4732 // 4([9223372036854775807, -4759477275222530853137]),
4733 QCBORDecode_GetDoubleConvertAll(&DCtx, QCBOR_CONVERT_TYPE_DECIMAL_FRACTION, &dResult);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004734 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS &&
Laurence Lundbladea826c502020-05-10 21:07:00 -07004735 dResult != -INFINITY) {
4736 return -2;
4737 }
4738
4739 // 5([300, 100]),
4740 QCBORDecode_GetDoubleConvertAll(&DCtx, QCBOR_CONVERT_TYPE_BIGFLOAT, &dResult);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004741 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS &&
Laurence Lundbladea826c502020-05-10 21:07:00 -07004742 dResult != -INFINITY) {
4743 return -2;
4744 }
4745
4746 // 5([-20, 4759477275222530853136]),
4747 QCBORDecode_GetDoubleConvertAll(&DCtx, QCBOR_CONVERT_TYPE_BIGFLOAT, &dResult);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004748 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS &&
Laurence Lundbladea826c502020-05-10 21:07:00 -07004749 dResult != 4521260802379792.0) {
4750 return -2;
4751 }
4752
4753 // 5([-9223372036854775807, -4759477275222530853137])
4754 QCBORDecode_GetDoubleConvertAll(&DCtx, QCBOR_CONVERT_TYPE_BIGFLOAT, &dResult);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004755 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS &&
Laurence Lundbladea826c502020-05-10 21:07:00 -07004756 dResult != -0.0) {
4757 return -2;
4758 }
4759
4760 // 5([9223372036854775806, 9223372036854775806])]
4761 QCBORDecode_GetDoubleConvertAll(&DCtx, QCBOR_CONVERT_TYPE_BIGFLOAT, &dResult);
Laurence Lundbladeb340ba72020-05-14 11:41:10 -07004762 if(QCBORDecode_GetError(&DCtx) != QCBOR_SUCCESS &&
Laurence Lundbladea826c502020-05-10 21:07:00 -07004763 dResult != INFINITY) {
4764 return -2;
4765 }
4766
Laurence Lundbladebb87be22020-04-09 19:15:32 -07004767 return 0;
Laurence Lundbladebb87be22020-04-09 19:15:32 -07004768}
Laurence Lundblade97c61bf2020-05-02 11:24:06 -07004769
4770
Laurence Lundbladee3553422020-05-02 11:11:17 -07004771int32_t CBORSequenceDecodeTests(void)
4772{
4773 QCBORDecodeContext DCtx;
4774 QCBORItem Item;
4775 QCBORError uCBORError;
4776
4777 // --- Test a sequence with extra bytes ---
4778
4779 // The input for the date test happens to be a sequence so it
4780 // is reused. It is a sequence because it doesn't start as
4781 // an array or map.
4782 QCBORDecode_Init(&DCtx,
4783 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spDateTestInput),
4784 QCBOR_DECODE_MODE_NORMAL);
4785
4786 // Get the first item
4787 uCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4788 if(uCBORError != QCBOR_SUCCESS) {
4789 return 1;
4790 }
4791 if(Item.uDataType != QCBOR_TYPE_DATE_STRING) {
4792 return 2;
4793 }
4794
4795 // Get a second item
4796 uCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4797 if(uCBORError != QCBOR_SUCCESS) {
4798 return 2;
4799 }
4800 if(Item.uDataType != QCBOR_TYPE_DATE_EPOCH) {
4801 return 3;
4802 }
4803
4804 // A sequence can have stuff at the end that may
4805 // or may not be valid CBOR. The protocol decoder knows
4806 // when to stop by definition of the protocol, not
4807 // when the top-level map or array is ended.
4808 // Finish still has to be called to know that
4809 // maps and arrays (if there were any) were closed
4810 // off correctly. When called like this it
4811 // must return the error QCBOR_ERR_EXTRA_BYTES.
4812 uCBORError = QCBORDecode_Finish(&DCtx);
4813 if(uCBORError != QCBOR_ERR_EXTRA_BYTES) {
4814 return 4;
4815 }
4816
4817
4818 // --- Test an empty input ----
4819 uint8_t empty[1];
4820 UsefulBufC Empty = {empty, 0};
4821 QCBORDecode_Init(&DCtx,
4822 Empty,
4823 QCBOR_DECODE_MODE_NORMAL);
4824
4825 uCBORError = QCBORDecode_Finish(&DCtx);
4826 if(uCBORError != QCBOR_SUCCESS) {
4827 return 5;
4828 }
4829
4830
4831 // --- Sequence with unclosed indefinite length array ---
4832 static const uint8_t xx[] = {0x01, 0x9f, 0x02};
4833
4834 QCBORDecode_Init(&DCtx,
4835 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(xx),
4836 QCBOR_DECODE_MODE_NORMAL);
4837
4838 // Get the first item
4839 uCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4840 if(uCBORError != QCBOR_SUCCESS) {
4841 return 7;
4842 }
4843 if(Item.uDataType != QCBOR_TYPE_INT64) {
4844 return 8;
4845 }
4846
4847 // Get a second item
4848 uCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4849 if(uCBORError != QCBOR_SUCCESS) {
4850 return 9;
4851 }
4852 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
4853 return 10;
4854 }
4855
4856 // Try to finish before consuming all bytes to confirm
4857 // that the still-open error is returned.
4858 uCBORError = QCBORDecode_Finish(&DCtx);
4859 if(uCBORError != QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN) {
4860 return 11;
4861 }
4862
4863
4864 // --- Sequence with a closed indefinite length array ---
4865 static const uint8_t yy[] = {0x01, 0x9f, 0xff};
4866
4867 QCBORDecode_Init(&DCtx,
4868 UsefulBuf_FROM_BYTE_ARRAY_LITERAL(yy),
4869 QCBOR_DECODE_MODE_NORMAL);
4870
4871 // Get the first item
4872 uCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4873 if(uCBORError != QCBOR_SUCCESS) {
4874 return 12;
4875 }
4876 if(Item.uDataType != QCBOR_TYPE_INT64) {
4877 return 13;
4878 }
4879
4880 // Get a second item
4881 uCBORError = QCBORDecode_GetNext(&DCtx, &Item);
4882 if(uCBORError != QCBOR_SUCCESS) {
4883 return 14;
4884 }
4885 if(Item.uDataType != QCBOR_TYPE_ARRAY) {
4886 return 15;
4887 }
4888
4889 // Try to finish before consuming all bytes to confirm
4890 // that the still-open error is returned.
4891 uCBORError = QCBORDecode_Finish(&DCtx);
4892 if(uCBORError != QCBOR_SUCCESS) {
4893 return 16;
4894 }
4895
4896
4897 return 0;
4898}
4899
Laurence Lundbladee15326f2020-06-15 15:50:23 -07004900
Laurence Lundblade70ecead2020-06-15 19:40:06 -07004901
Laurence Lundbladee15326f2020-06-15 15:50:23 -07004902int32_t IntToTests()
4903{
4904 int nErrCode;
4905 int32_t n32;
4906 int16_t n16;
4907 int8_t n8;
4908 uint32_t u32;
4909 uint16_t u16;
4910 uint8_t u8;
4911 uint64_t u64;
4912
4913 nErrCode = QCBOR_Int64ToInt32(1, &n32);
4914 if(nErrCode == -1 || n32 != 1) {
4915 return 1;
4916 }
4917
4918 nErrCode = QCBOR_Int64ToInt32((int64_t)INT32_MAX, &n32);
4919 if(nErrCode == -1 || n32 != INT32_MAX) {
4920 return 2;
4921 }
4922
4923 nErrCode = QCBOR_Int64ToInt32((int64_t)INT32_MIN, &n32);
4924 if(nErrCode == -1 || n32 != INT32_MIN) {
4925 return 3;
4926 }
4927
4928 nErrCode = QCBOR_Int64ToInt32(((int64_t)INT32_MAX)+1, &n32);
4929 if(nErrCode != -1) {
4930 return 4;
4931 }
4932
4933 nErrCode = QCBOR_Int64ToInt32(((int64_t)INT32_MIN)-1, &n32);
4934 if(nErrCode != -1) {
4935 return 5;
4936 }
4937
4938
4939 nErrCode = QCBOR_Int64ToInt16((int64_t)INT16_MAX, &n16);
4940 if(nErrCode == -1 || n16 != INT16_MAX) {
4941 return 6;
4942 }
4943
4944 nErrCode = QCBOR_Int64ToInt16((int64_t)INT16_MIN, &n16);
4945 if(nErrCode == -1 || n16 != INT16_MIN) {
4946 return 7;
4947 }
4948
4949 nErrCode = QCBOR_Int64ToInt16(1, &n16);
4950 if(nErrCode == -1 || n16 != 1) {
4951 return 8;
4952 }
4953
4954 nErrCode = QCBOR_Int64ToInt16(((int64_t)INT16_MAX)+1, &n16);
4955 if(nErrCode != -1) {
4956 return 9;
4957 }
4958
4959 nErrCode = QCBOR_Int64ToInt16(((int64_t)INT16_MIN)-1, &n16);
4960 if(nErrCode != -1) {
4961 return 10;
4962 }
4963
4964
4965 nErrCode = QCBOR_Int64ToInt8(1, &n8);
4966 if(nErrCode == -1 || n8 != 1) {
4967 return 11;
4968 }
4969
4970 nErrCode = QCBOR_Int64ToInt8((int64_t)INT8_MAX, &n8);
4971 if(nErrCode == -1 || n8 != INT8_MAX) {
4972 return 12;
4973 }
4974
4975 nErrCode = QCBOR_Int64ToInt8((int64_t)INT8_MIN, &n8);
4976 if(nErrCode == -1 || n8 != INT8_MIN) {
4977 return 13;
4978 }
4979
4980 nErrCode = QCBOR_Int64ToInt8(((int64_t)INT8_MAX)+1, &n8);
4981 if(nErrCode != -1) {
4982 return 14;
4983 }
4984
4985 nErrCode = QCBOR_Int64ToInt8(((int64_t)INT8_MIN)-1, &n8);
4986 if(nErrCode != -1) {
4987 return 15;
4988 }
4989
4990
4991 nErrCode = QCBOR_Int64ToUInt32(1, &u32);
4992 if(nErrCode == -1 || u32 != 1) {
4993 return 16;
4994 }
4995
4996 nErrCode = QCBOR_Int64ToUInt32((int64_t)UINT32_MAX, &u32);
4997 if(nErrCode == -1 || u32 != UINT32_MAX) {
4998 return 17;
4999 }
5000
5001 nErrCode = QCBOR_Int64ToUInt32((int64_t)0, &u32);
5002 if(nErrCode == -1 || u32 != 0) {
5003 return 18;
5004 }
5005
5006 nErrCode = QCBOR_Int64ToUInt32(((int64_t)UINT32_MAX)+1, &u32);
5007 if(nErrCode != -1) {
5008 return 19;
5009 }
5010
5011 nErrCode = QCBOR_Int64ToUInt32((int64_t)-1, &u32);
5012 if(nErrCode != -1) {
5013 return 20;
5014 }
5015
5016
5017 nErrCode = QCBOR_Int64UToInt16((int64_t)UINT16_MAX, &u16);
5018 if(nErrCode == -1 || u16 != UINT16_MAX) {
5019 return 21;
5020 }
5021
5022 nErrCode = QCBOR_Int64UToInt16((int64_t)0, &u16);
5023 if(nErrCode == -1 || u16 != 0) {
5024 return 22;
5025 }
5026
5027 nErrCode = QCBOR_Int64UToInt16(1, &u16);
5028 if(nErrCode == -1 || u16 != 1) {
5029 return 23;
5030 }
5031
5032 nErrCode = QCBOR_Int64UToInt16(((int64_t)UINT16_MAX)+1, &u16);
5033 if(nErrCode != -1) {
5034 return 24;
5035 }
5036
5037 nErrCode = QCBOR_Int64UToInt16((int64_t)-1, &u16);
5038 if(nErrCode != -1) {
5039 return 25;
5040 }
5041
5042
5043 nErrCode = QCBOR_Int64ToUInt8((int64_t)UINT8_MAX, &u8);
5044 if(nErrCode == -1 || u8 != UINT8_MAX) {
5045 return 26;
5046 }
5047
5048 nErrCode = QCBOR_Int64ToUInt8((int64_t)0, &u8);
5049 if(nErrCode == -1 || u8 != 0) {
5050 return 27;
5051 }
5052
5053 nErrCode = QCBOR_Int64ToUInt8(1, &u8);
5054 if(nErrCode == -1 || u8 != 1) {
5055 return 28;
5056 }
5057
5058 nErrCode = QCBOR_Int64ToUInt8(((int64_t)UINT16_MAX)+1, &u8);
5059 if(nErrCode != -1) {
5060 return 29;
5061 }
5062
5063 nErrCode = QCBOR_Int64ToUInt8((int64_t)-1, &u8);
5064 if(nErrCode != -1) {
5065 return 30;
5066 }
5067
5068
5069 nErrCode = QCBOR_Int64ToUInt64(1, &u64);
5070 if(nErrCode == -1 || u64 != 1) {
5071 return 31;
5072 }
5073
5074 nErrCode = QCBOR_Int64ToUInt64(INT64_MAX, &u64);
5075 if(nErrCode == -1 || u64 != INT64_MAX) {
5076 return 32;
5077 }
5078
5079 nErrCode = QCBOR_Int64ToUInt64((int64_t)0, &u64);
5080 if(nErrCode == -1 || u64 != 0) {
5081 return 33;
5082 }
5083
5084 nErrCode = QCBOR_Int64ToUInt64((int64_t)-1, &u64);
5085 if(nErrCode != -1) {
5086 return 34;
5087 }
5088
5089 return 0;
5090}
5091
Laurence Lundblade0750fc42020-06-20 21:02:34 -07005092
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005093
5094
Laurence Lundblade0750fc42020-06-20 21:02:34 -07005095/*
5096A sequence with
5097 A wrapping bstr
5098 containing a map
5099 1
5100 2
5101 A wrapping bstr
5102 containing an array
5103 3
5104 wrapping bstr
5105 4
5106 5
5107 6
5108 array
5109 7
5110 8
5111
5112 */
5113
5114static UsefulBufC foo(UsefulBuf ffo)
5115{
5116 UsefulBufC Encoded;
5117 QCBOREncodeContext EC;
5118 QCBORError uErr;
5119
5120 QCBOREncode_Init(&EC, ffo);
5121
5122 QCBOREncode_BstrWrap(&EC);
5123 QCBOREncode_OpenMap(&EC);
5124 QCBOREncode_AddInt64ToMapN(&EC, 100, 1);
5125 QCBOREncode_AddInt64ToMapN(&EC, 200, 2);
5126 QCBOREncode_CloseMap(&EC);
5127 QCBOREncode_BstrWrap(&EC);
5128 QCBOREncode_OpenArray(&EC);
5129 QCBOREncode_AddInt64(&EC, 3);
5130 QCBOREncode_BstrWrap(&EC);
5131 QCBOREncode_AddInt64(&EC, 4);
5132 QCBOREncode_CloseBstrWrap(&EC, NULL);
5133 QCBOREncode_AddInt64(&EC, 5);
5134 QCBOREncode_CloseArray(&EC);
5135 QCBOREncode_CloseBstrWrap(&EC, NULL);
5136 QCBOREncode_AddInt64(&EC, 6);
5137 QCBOREncode_CloseBstrWrap(&EC, NULL);
5138 QCBOREncode_OpenArray(&EC);
5139 QCBOREncode_AddInt64(&EC, 7);
5140 QCBOREncode_AddInt64(&EC, 8);
5141 QCBOREncode_CloseArray(&EC);
5142
5143 uErr = QCBOREncode_Finish(&EC, &Encoded);
Laurence Lundblade40a04322020-06-27 22:52:52 -07005144 if(uErr) {
5145 Encoded = NULLUsefulBufC;
5146 }
Laurence Lundblade0750fc42020-06-20 21:02:34 -07005147
5148 return Encoded;
5149}
5150
5151
5152int32_t EnterBstrTest()
5153{
5154 MakeUsefulBufOnStack(ffo, 100);
5155
5156 QCBORDecodeContext DC;
5157
5158 QCBORDecode_Init(&DC, foo(ffo), 0);
5159
5160 int64_t i1, i2, i3, i4, i5, i6, i7, i8;
5161
5162
Laurence Lundbladef9175a92020-07-30 21:35:45 -07005163 QCBORDecode_EnterBstrWrapped(&DC, QCBOR_TAG_REQUIREMENT_NO_TAG, NULL);
Laurence Lundblade0750fc42020-06-20 21:02:34 -07005164 QCBORDecode_EnterMap(&DC);
5165 QCBORDecode_GetInt64InMapN(&DC, 100, &i1);
5166 QCBORDecode_GetInt64InMapN(&DC, 200, &i2);
5167 QCBORDecode_ExitMap(&DC);
Laurence Lundbladef9175a92020-07-30 21:35:45 -07005168 QCBORDecode_EnterBstrWrapped(&DC, QCBOR_TAG_REQUIREMENT_NO_TAG, NULL);
Laurence Lundblade0750fc42020-06-20 21:02:34 -07005169 QCBORDecode_EnterArray(&DC);
5170 QCBORDecode_GetInt64(&DC, &i3);
Laurence Lundbladef9175a92020-07-30 21:35:45 -07005171 QCBORDecode_EnterBstrWrapped(&DC, QCBOR_TAG_REQUIREMENT_NO_TAG, NULL);
Laurence Lundblade0750fc42020-06-20 21:02:34 -07005172 QCBORDecode_GetInt64(&DC, &i4);
5173 QCBORDecode_ExitBstrWrapped(&DC);
5174 QCBORDecode_GetInt64(&DC, &i5);
5175 QCBORDecode_ExitArray(&DC);
5176 QCBORDecode_ExitBstrWrapped(&DC);
5177 QCBORDecode_GetInt64(&DC, &i6);
5178 QCBORDecode_ExitBstrWrapped(&DC);
5179 QCBORDecode_EnterArray(&DC);
5180 QCBORDecode_GetInt64(&DC, &i7);
5181 QCBORDecode_GetInt64(&DC, &i8);
5182 QCBORDecode_ExitArray(&DC);
5183
5184 QCBORError uErr = QCBORDecode_Finish(&DC);
5185
5186 return (int32_t)uErr;
5187}
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005188
5189
5190
5191
5192static const uint8_t spTaggedTypes[] = {
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005193 0xb2,
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005194
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005195 // Date string
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005196 0x00,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005197 0xc0, 0x74, 0x32, 0x30, 0x30, 0x33, 0x2D, 0x31, 0x32, 0x2D,
5198 0x31, 0x33, 0x54, 0x31, 0x38, 0x3A, 0x33, 0x30, 0x3A, 0x30,
5199 0x32, 0x5A,
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005200
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005201 0x01,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005202 0x74, 0x32, 0x30, 0x30, 0x33, 0x2D, 0x31, 0x32, 0x2D, 0x31,
5203 0x33, 0x54, 0x31, 0x38, 0x3A, 0x33, 0x30, 0x3A, 0x30, 0x32,
5204 0x5A,
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005205
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005206 // Bignum
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005207 10,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005208 0xC2, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
5209 0x09, 0x10,
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005210
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005211 11,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005212 0xC3, 0x4A, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
5213 0x09, 0x10,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005214
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005215 // URL
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005216 20,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005217 0xd8, 0x20, 0x6f, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F,
5218 0x63, 0x62, 0x6F, 0x72, 0x2E, 0x6D, 0x65, 0x2F,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005219
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005220 21,
5221 0x6f, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x63, 0x62,
5222 0x6F, 0x72, 0x2E, 0x6D, 0x65, 0x2F,
5223
5224 // B64
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005225 0x18, 0x1e,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005226 0xd8, 0x22, 0x6c, 0x63, 0x47, 0x78, 0x6C, 0x59, 0x58, 0x4E,
5227 0x31, 0x63, 0x6D, 0x55, 0x75,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005228
5229 0x18, 0x1f,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005230 0x6c, 0x63, 0x47, 0x78, 0x6C, 0x59, 0x58, 0x4E, 0x31, 0x63,
5231 0x6D, 0x55, 0x75,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005232
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005233 // B64URL
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005234 0x18, 0x28,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005235 0xd8, 0x21, 0x6c, 0x63, 0x47, 0x78, 0x6C, 0x59, 0x58, 0x4E,
5236 0x31, 0x63, 0x6D, 0x55, 0x75,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005237
5238 0x18, 0x29,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005239 0x6c, 0x63, 0x47, 0x78, 0x6C, 0x59, 0x58, 0x4E, 0x31, 0x63,
5240 0x6D, 0x55, 0x75,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005241
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005242 // Regex
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005243 0x18, 0x32,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005244 0xd8, 0x23, 0x68, 0x31, 0x30, 0x30, 0x5C, 0x73, 0x2A, 0x6D,
5245 0x6B,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005246
5247 0x18, 0x33,
5248 0x68, 0x31, 0x30, 0x30, 0x5C, 0x73, 0x2A, 0x6D, 0x6B,
5249
5250 // MIME
5251 0x18, 0x3c,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005252 0xd8, 0x24, 0x72, 0x4D, 0x49, 0x4D, 0x45, 0x2D, 0x56, 0x65,
5253 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x3A, 0x20, 0x31, 0x2E, 0x30,
5254 0x0A,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005255
5256 0x18, 0x3d,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005257 0x72, 0x4D, 0x49, 0x4D, 0x45, 0x2D, 0x56, 0x65, 0x72, 0x73,
5258 0x69, 0x6F, 0x6E, 0x3A, 0x20, 0x31, 0x2E, 0x30, 0x0A,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005259
5260 0x18, 0x3e,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005261 0xd9, 0x01, 0x01, 0x52, 0x4D, 0x49, 0x4D, 0x45, 0x2D, 0x56,
5262 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x3A, 0x20, 0x31, 0x2E,
5263 0x30, 0x0A,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005264
5265 0x18, 0x3f,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005266 0x52, 0x4D, 0x49, 0x4D, 0x45, 0x2D, 0x56, 0x65, 0x72, 0x73,
5267 0x69, 0x6F, 0x6E, 0x3A, 0x20, 0x31, 0x2E, 0x30, 0x0A,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005268
5269 // UUID
5270 0x18, 0x46,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005271 0xd8, 0x25, 0x50, 0x53, 0x4D, 0x41, 0x52, 0x54, 0x43, 0x53,
5272 0x4C, 0x54, 0x54, 0x43, 0x46, 0x49, 0x43, 0x41, 0x32,
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005273
5274 0x18, 0x47,
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005275 0x50, 0x53, 0x4D, 0x41, 0x52, 0x54, 0x43, 0x53, 0x4C, 0x54,
5276 0x54, 0x43, 0x46, 0x49, 0x43, 0x41, 0x32
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005277};
5278
5279int32_t DecodeTaggedTypeTests()
5280{
5281 QCBORDecodeContext DC;
5282 QCBORError uErr;
5283
5284 QCBORDecode_Init(&DC, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spTaggedTypes), 0);
5285
5286 UsefulBufC String;
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005287 bool bNeg;
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005288
5289 QCBORDecode_EnterMap(&DC);
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005290 QCBORDecode_GetDateStringInMapN(&DC, 0, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5291 QCBORDecode_GetDateStringInMapN(&DC, 0, QCBOR_TAG_REQUIREMENT_OPTIONAL_TAG, &String);
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005292 if(QCBORDecode_GetError(&DC) != QCBOR_SUCCESS) {
5293 return 1;
5294 }
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005295 QCBORDecode_GetDateStringInMapN(&DC, 0, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005296 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_UNEXPECTED_TYPE) {
5297 return 2;
5298 }
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005299 QCBORDecode_GetDateStringInMapN(&DC, 1, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005300 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_UNEXPECTED_TYPE) {
5301 return 3;
5302 }
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005303 QCBORDecode_GetDateStringInMapN(&DC, 1, QCBOR_TAG_REQUIREMENT_OPTIONAL_TAG, &String);
5304 QCBORDecode_GetDateStringInMapN(&DC, 1, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005305 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5306 return 4;
5307 }
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005308 QCBORDecode_GetDateStringInMapSZ(&DC, "xxx", QCBOR_TAG_REQUIREMENT_OPTIONAL_TAG, &String);
5309 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5310 return 5;
5311 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005312
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005313 QCBORDecode_GetBignumInMapN(&DC, 10, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String, &bNeg);
5314 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS ||
5315 bNeg != false) {
5316 return 10;
5317 }
5318 QCBORDecode_GetBignumInMapN(&DC, 11, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String, &bNeg);
5319 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS ||
5320 bNeg != true) {
5321 return 11;
5322 }
5323 QCBORDecode_GetBignumInMapN(&DC, 11, QCBOR_TAG_REQUIREMENT_NO_TAG, &String, &bNeg);
5324 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_UNEXPECTED_TYPE) {
5325 return 12;
5326 }
5327 QCBORDecode_GetBignumInMapN(&DC, 14, QCBOR_TAG_REQUIREMENT_NO_TAG, &String, &bNeg);
5328 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5329 return 13;
5330 }
5331 QCBORDecode_GetBignumInMapSZ(&DC, "xxx", QCBOR_TAG_REQUIREMENT_NO_TAG, &String, &bNeg);
5332 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5333 return 14;
5334 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005335
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005336 QCBORDecode_GetURIInMapN(&DC, 20, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5337 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5338 return 20;
5339 }
5340 QCBORDecode_GetURIInMapN(&DC, 21, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5341 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5342 return 21;
5343 }
5344 QCBORDecode_GetURIInMapN(&DC, 22, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5345 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5346 return 22;
5347 }
5348 QCBORDecode_GetURIInMapSZ(&DC, "xxx", QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5349 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5350 return 23;
5351 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005352
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005353 QCBORDecode_GetB64InMapN(&DC, 30, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5354 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5355 return 30;
5356 }
5357 QCBORDecode_GetB64InMapN(&DC, 31, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5358 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5359 return 31;
5360 }
5361 QCBORDecode_GetB64InMapN(&DC, 32, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5362 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5363 return 32;
5364 }
5365 QCBORDecode_GetB64InMapSZ(&DC, "xxx", QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5366 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5367 return 33;
5368 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005369
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005370 QCBORDecode_GetB64URLInMapN(&DC, 40, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5371 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5372 return 40;
5373 }
5374 QCBORDecode_GetB64URLInMapN(&DC, 41, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5375 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5376 return 41;
5377 }
5378 QCBORDecode_GetB64URLInMapN(&DC, 42, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5379 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5380 return 42;
5381 }
5382 QCBORDecode_GetB64URLInMapSZ(&DC, "xxx", QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5383 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5384 return 43;
5385 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005386
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005387 QCBORDecode_GetRegexInMapN(&DC, 50, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5388 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5389 return 50;
5390 }
5391 QCBORDecode_GetRegexInMapN(&DC, 51, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5392 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5393 return 51;
5394 }
5395 QCBORDecode_GetRegexInMapN(&DC, 52, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5396 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5397 return 52;
5398 }
5399 QCBORDecode_GetRegexInMapSZ(&DC, "xxx", QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5400 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5401 return 53;
5402 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005403
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005404 // MIME
5405 bool bIsNot7Bit;
5406 QCBORDecode_GetMIMEMessageInMapN(&DC, 60, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String, &bIsNot7Bit);
5407 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS ||
5408 bIsNot7Bit == true) {
5409 return 60;
5410 }
5411 QCBORDecode_GetMIMEMessageInMapN(&DC, 61, QCBOR_TAG_REQUIREMENT_NO_TAG, &String, &bIsNot7Bit);
5412 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS ||
5413 bIsNot7Bit == true) {
5414 return 61;
5415 }
5416 QCBORDecode_GetMIMEMessageInMapN(&DC, 62, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String, &bIsNot7Bit);
5417 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS ||
5418 bIsNot7Bit == false) {
5419 return 62;
5420 }
5421 QCBORDecode_GetMIMEMessageInMapN(&DC, 63, QCBOR_TAG_REQUIREMENT_NO_TAG, &String, &bIsNot7Bit);
5422 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS ||
5423 bIsNot7Bit == false) {
5424 return 63;
5425 }
5426 QCBORDecode_GetMIMEMessageInMapN(&DC, 64, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String, &bNeg);
5427 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5428 return 64;
5429 }
5430 QCBORDecode_GetMIMEMessageInMapSZ(&DC, "zzz", QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String, &bNeg);
5431 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5432 return 65;
5433 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005434
Laurence Lundblade2f5e16d2020-08-04 20:35:23 -07005435 QCBORDecode_GetBinaryUUIDInMapN(&DC, 70, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5436 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5437 return 70;
5438 }
5439 QCBORDecode_GetBinaryUUIDInMapN(&DC, 71, QCBOR_TAG_REQUIREMENT_NO_TAG, &String);
5440 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_SUCCESS) {
5441 return 71;
5442 }
5443 QCBORDecode_GetBinaryUUIDInMapN(&DC, 72, QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5444 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5445 return 72;
5446 }
5447 QCBORDecode_GetBinaryUUIDInMapSZ(&DC, "xxx", QCBOR_TAG_REQUIREMENT_MATCH_TAG, &String);
5448 if(QCBORDecode_GetAndResetError(&DC) != QCBOR_ERR_NOT_FOUND) {
5449 return 73;
5450 }
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005451
Laurence Lundblade9bb039a2020-08-05 12:25:15 -07005452 // Improvement: add some more error test cases
5453
Laurence Lundblade37f46e52020-08-04 03:32:14 -07005454 QCBORDecode_ExitMap(&DC);
5455
5456 uErr = QCBORDecode_Finish(&DC);
5457 if(uErr != QCBOR_SUCCESS) {
5458 return 100;
5459 }
5460
5461 return 0;
5462}