1 /*
2 * Copyright (c) 2014-2019 Pavel Kalvoda <me@pavelkalvoda.com>
3 *
4 * libcbor is free software; you can redistribute it and/or modify
5 * it under the terms of the MIT license. See LICENSE for details.
6 */
7
8 #include <setjmp.h>
9 #include <stdarg.h>
10 #include <stddef.h>
11
12 #include <cmocka.h>
13
14 #include "assertions.h"
15 #include "cbor.h"
16 #include "stream_expectations.h"
17
18 unsigned char embedded_uint8_data[] = {0x00, 0x01, 0x05, 0x17};
test_uint8_embedded_decoding(void ** state)19 static void test_uint8_embedded_decoding(void **state) {
20 assert_uint8_eq(0);
21 assert_decoder_result(1, CBOR_DECODER_FINISHED,
22 decode(embedded_uint8_data, 1));
23
24 assert_uint8_eq(1);
25 assert_decoder_result(1, CBOR_DECODER_FINISHED,
26 decode(embedded_uint8_data + 1, 1));
27
28 assert_uint8_eq(5);
29 assert_decoder_result(1, CBOR_DECODER_FINISHED,
30 decode(embedded_uint8_data + 2, 1));
31
32 assert_uint8_eq(23);
33 assert_decoder_result(1, CBOR_DECODER_FINISHED,
34 decode(embedded_uint8_data + 3, 1));
35 }
36
37 unsigned char uint8_data[] = {0x18, 0x83, 0x18, 0xFF};
test_uint8_decoding(void ** state)38 static void test_uint8_decoding(void **state) {
39 assert_uint8_eq(0x83);
40 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(uint8_data, 2));
41
42 assert_uint8_eq(0xFF);
43 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(uint8_data + 2, 2));
44 }
45
46 unsigned char uint16_data[] = {0x19, 0x01, 0xf4};
test_uint16_decoding(void ** state)47 static void test_uint16_decoding(void **state) {
48 assert_uint16_eq(500);
49 assert_decoder_result(3, CBOR_DECODER_FINISHED, decode(uint16_data, 3));
50 }
51
52 unsigned char uint32_data[] = {0x1a, 0xa5, 0xf7, 0x02, 0xb3};
test_uint32_decoding(void ** state)53 static void test_uint32_decoding(void **state) {
54 assert_uint32_eq((uint32_t)2784428723UL);
55 assert_decoder_result(5, CBOR_DECODER_FINISHED, decode(uint32_data, 5));
56 }
57
58 unsigned char uint64_data[] = {0x1b, 0xa5, 0xf7, 0x02, 0xb3,
59 0xa5, 0xf7, 0x02, 0xb3};
test_uint64_decoding(void ** state)60 static void test_uint64_decoding(void **state) {
61 assert_uint64_eq(11959030306112471731ULL);
62 assert_decoder_result(9, CBOR_DECODER_FINISHED, decode(uint64_data, 9));
63 }
64
65 unsigned char embedded_negint8_data[] = {0x20, 0x21, 0x25, 0x37};
test_negint8_embedded_decoding(void ** state)66 static void test_negint8_embedded_decoding(void **state) {
67 assert_negint8_eq(0);
68 assert_decoder_result(1, CBOR_DECODER_FINISHED,
69 decode(embedded_negint8_data, 1));
70
71 assert_negint8_eq(1);
72 assert_decoder_result(1, CBOR_DECODER_FINISHED,
73 decode(embedded_negint8_data + 1, 1));
74
75 assert_negint8_eq(5);
76 assert_decoder_result(1, CBOR_DECODER_FINISHED,
77 decode(embedded_negint8_data + 2, 1));
78
79 assert_negint8_eq(23);
80 assert_decoder_result(1, CBOR_DECODER_FINISHED,
81 decode(embedded_negint8_data + 3, 1));
82 }
83
84 unsigned char negint8_data[] = {0x38, 0x83, 0x38, 0xFF};
test_negint8_decoding(void ** state)85 static void test_negint8_decoding(void **state) {
86 assert_negint8_eq(0x83);
87 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(negint8_data, 2));
88
89 assert_negint8_eq(0xFF);
90 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(negint8_data + 2, 2));
91 }
92
93 unsigned char negint16_data[] = {0x39, 0x01, 0xf4};
test_negint16_decoding(void ** state)94 static void test_negint16_decoding(void **state) {
95 assert_negint16_eq(500);
96 assert_decoder_result(3, CBOR_DECODER_FINISHED, decode(negint16_data, 3));
97 }
98
99 unsigned char negint32_data[] = {0x3a, 0xa5, 0xf7, 0x02, 0xb3};
test_negint32_decoding(void ** state)100 static void test_negint32_decoding(void **state) {
101 assert_negint32_eq((uint32_t)2784428723UL);
102 assert_decoder_result(5, CBOR_DECODER_FINISHED, decode(negint32_data, 5));
103 }
104
105 unsigned char negint64_data[] = {0x3b, 0xa5, 0xf7, 0x02, 0xb3,
106 0xa5, 0xf7, 0x02, 0xb3};
test_negint64_decoding(void ** state)107 static void test_negint64_decoding(void **state) {
108 assert_negint64_eq(11959030306112471731ULL);
109 assert_decoder_result(9, CBOR_DECODER_FINISHED, decode(negint64_data, 9));
110 }
111
112 unsigned char bstring_embedded_int8_data[] = {0x41, 0xFF};
test_bstring_embedded_int8_decoding(void ** state)113 static void test_bstring_embedded_int8_decoding(void **state) {
114 assert_bstring_mem_eq(bstring_embedded_int8_data + 1, 1);
115 assert_decoder_result(2, CBOR_DECODER_FINISHED,
116 decode(bstring_embedded_int8_data, 2));
117 }
118
119 unsigned char bstring_int8_data[] = {0x58, 0x00};
test_bstring_int8_decoding(void ** state)120 static void test_bstring_int8_decoding(void **state) {
121 assert_bstring_mem_eq(bstring_int8_data + 2, 0);
122 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(bstring_int8_data, 2));
123 }
124
125 unsigned char bstring_int16_data[] = {0x59, 0x01, 0x5C /*, [348 bytes] */};
test_bstring_int16_decoding(void ** state)126 static void test_bstring_int16_decoding(void **state) {
127 assert_bstring_mem_eq(bstring_int16_data + 3, 348);
128 assert_decoder_result(3 + 348, CBOR_DECODER_FINISHED,
129 decode(bstring_int16_data, 3 + 348));
130 }
131
132 unsigned char bstring_int32_data[] = {0x5A, 0x00, 0x10, 0x10,
133 0x10 /*, [1052688 bytes] */};
test_bstring_int32_decoding(void ** state)134 static void test_bstring_int32_decoding(void **state) {
135 assert_bstring_mem_eq(bstring_int32_data + 5, 1052688);
136 assert_decoder_result(5 + 1052688, CBOR_DECODER_FINISHED,
137 decode(bstring_int32_data, 5 + 1052688));
138 }
139
140 #ifdef EIGHT_BYTE_SIZE_T
141 unsigned char bstring_int64_data[] = {
142 0x5B, 0x00, 0x00, 0x00, 0x01,
143 0x00, 0x00, 0x00, 0x00 /*, [4294967296 bytes] */};
test_bstring_int64_decoding(void ** state)144 static void test_bstring_int64_decoding(void **state) {
145 assert_bstring_mem_eq(bstring_int64_data + 9, 4294967296);
146 assert_decoder_result(9 + 4294967296, CBOR_DECODER_FINISHED,
147 decode(bstring_int64_data, 9 + 4294967296));
148 }
149 #endif
150
151 unsigned char bstring_indef_1_data[] = {0x5F, 0x40 /* Empty byte string */,
152 0xFF};
test_bstring_indef_decoding_1(void ** state)153 static void test_bstring_indef_decoding_1(void **state) {
154 assert_bstring_indef_start();
155 assert_decoder_result(1, CBOR_DECODER_FINISHED,
156 decode(bstring_indef_1_data, 3));
157
158 assert_bstring_mem_eq(bstring_indef_1_data + 2, 0);
159 assert_decoder_result(1, CBOR_DECODER_FINISHED,
160 decode(bstring_indef_1_data + 1, 2));
161
162 assert_indef_break();
163 assert_decoder_result(1, CBOR_DECODER_FINISHED,
164 decode(bstring_indef_1_data + 2, 1));
165 }
166
167 unsigned char bstring_indef_2_data[] = {0x5F, 0xFF};
test_bstring_indef_decoding_2(void ** state)168 static void test_bstring_indef_decoding_2(void **state) {
169 assert_bstring_indef_start();
170 assert_decoder_result(1, CBOR_DECODER_FINISHED,
171 decode(bstring_indef_2_data, 2));
172
173 assert_indef_break();
174 assert_decoder_result(1, CBOR_DECODER_FINISHED,
175 decode(bstring_indef_2_data + 1, 1));
176 }
177
178 unsigned char bstring_indef_3_data[] = {
179 0x5F, 0x40 /* Empty byte string */, 0x58,
180 0x01, 0xFF /* 1B 1 char bytes string */, 0xFF};
test_bstring_indef_decoding_3(void ** state)181 static void test_bstring_indef_decoding_3(void **state) {
182 assert_bstring_indef_start();
183 assert_decoder_result(1, CBOR_DECODER_FINISHED,
184 decode(bstring_indef_3_data, 6));
185
186 assert_bstring_mem_eq(bstring_indef_3_data + 2, 0);
187 assert_decoder_result(1, CBOR_DECODER_FINISHED,
188 decode(bstring_indef_3_data + 1, 5));
189
190 assert_bstring_mem_eq(bstring_indef_3_data + 4, 1);
191 assert_decoder_result(3, CBOR_DECODER_FINISHED,
192 decode(bstring_indef_3_data + 2, 4));
193
194 assert_indef_break();
195 assert_decoder_result(1, CBOR_DECODER_FINISHED,
196 decode(bstring_indef_3_data + 5, 1));
197 }
198
199 unsigned char array_embedded_int8_data[] = {0x80};
test_array_embedded_int8_decoding(void ** state)200 static void test_array_embedded_int8_decoding(void **state) {
201 assert_array_start(0);
202 assert_decoder_result(1, CBOR_DECODER_FINISHED,
203 decode(array_embedded_int8_data, 1));
204 }
205
206 unsigned char array_int8_data[] = {0x98, 0x02, 0x00, 0x01};
test_array_int8_decoding(void ** state)207 static void test_array_int8_decoding(void **state) {
208 assert_array_start(2);
209 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(array_int8_data, 4));
210
211 assert_uint8_eq(0);
212 assert_decoder_result(1, CBOR_DECODER_FINISHED,
213 decode(array_int8_data + 2, 2));
214
215 assert_uint8_eq(1);
216 assert_decoder_result(1, CBOR_DECODER_FINISHED,
217 decode(array_int8_data + 3, 1));
218 }
219
220 unsigned char array_int16_data[] = {0x99, 0x00, 0x02, 0x00, 0x01};
test_array_int16_decoding(void ** state)221 static void test_array_int16_decoding(void **state) {
222 assert_array_start(2);
223 assert_decoder_result(3, CBOR_DECODER_FINISHED, decode(array_int16_data, 5));
224
225 assert_uint8_eq(0);
226 assert_decoder_result(1, CBOR_DECODER_FINISHED,
227 decode(array_int16_data + 3, 2));
228
229 assert_uint8_eq(1);
230 assert_decoder_result(1, CBOR_DECODER_FINISHED,
231 decode(array_int16_data + 4, 1));
232 }
233
234 unsigned char array_int32_data[] = {0x9A, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01};
test_array_int32_decoding(void ** state)235 static void test_array_int32_decoding(void **state) {
236 assert_array_start(2);
237 assert_decoder_result(5, CBOR_DECODER_FINISHED, decode(array_int32_data, 7));
238
239 assert_uint8_eq(0);
240 assert_decoder_result(1, CBOR_DECODER_FINISHED,
241 decode(array_int32_data + 5, 2));
242
243 assert_uint8_eq(1);
244 assert_decoder_result(1, CBOR_DECODER_FINISHED,
245 decode(array_int32_data + 6, 1));
246 }
247
248 unsigned char array_int64_data[] = {0x9B, 0x00, 0x00, 0x00, 0x00, 0x00,
249 0x00, 0x00, 0x02, 0x00, 0x01};
test_array_int64_decoding(void ** state)250 static void test_array_int64_decoding(void **state) {
251 assert_array_start(2);
252 assert_decoder_result(9, CBOR_DECODER_FINISHED, decode(array_int64_data, 11));
253
254 assert_uint8_eq(0);
255 assert_decoder_result(1, CBOR_DECODER_FINISHED,
256 decode(array_int64_data + 9, 2));
257
258 assert_uint8_eq(1);
259 assert_decoder_result(1, CBOR_DECODER_FINISHED,
260 decode(array_int64_data + 10, 1));
261 }
262
263 unsigned char array_of_arrays_data[] = {0x82, 0x80, 0x80};
test_array_of_arrays_decoding(void ** state)264 static void test_array_of_arrays_decoding(void **state) {
265 assert_array_start(2);
266 assert_decoder_result(1, CBOR_DECODER_FINISHED,
267 decode(array_of_arrays_data, 3));
268
269 assert_array_start(0);
270 assert_decoder_result(1, CBOR_DECODER_FINISHED,
271 decode(array_of_arrays_data + 1, 2));
272
273 assert_array_start(0);
274 assert_decoder_result(1, CBOR_DECODER_FINISHED,
275 decode(array_of_arrays_data + 2, 1));
276 }
277
278 unsigned char indef_array_data_1[] = {0x9F, 0x00, 0x18, 0xFF, 0x9F, 0xFF, 0xFF};
test_indef_array_decoding_1(void ** state)279 static void test_indef_array_decoding_1(void **state) {
280 assert_indef_array_start();
281 assert_decoder_result(1, CBOR_DECODER_FINISHED,
282 decode(indef_array_data_1, 7));
283
284 assert_uint8_eq(0);
285 assert_decoder_result(1, CBOR_DECODER_FINISHED,
286 decode(indef_array_data_1 + 1, 6));
287
288 assert_uint8_eq(255);
289 assert_decoder_result(2, CBOR_DECODER_FINISHED,
290 decode(indef_array_data_1 + 2, 4));
291
292 assert_indef_array_start();
293 assert_decoder_result(1, CBOR_DECODER_FINISHED,
294 decode(indef_array_data_1 + 4, 3));
295
296 assert_indef_break();
297 assert_decoder_result(1, CBOR_DECODER_FINISHED,
298 decode(indef_array_data_1 + 5, 2));
299
300 assert_indef_break();
301 assert_decoder_result(1, CBOR_DECODER_FINISHED,
302 decode(indef_array_data_1 + 6, 1));
303 }
304
305 unsigned char map_embedded_int8_data[] = {0xa1, 0x01, 0x00};
test_map_embedded_int8_decoding(void ** state)306 static void test_map_embedded_int8_decoding(void **state) {
307 assert_map_start(1);
308 assert_decoder_result(1, CBOR_DECODER_FINISHED,
309 decode(map_embedded_int8_data, 3));
310
311 assert_uint8_eq(1);
312 assert_decoder_result(1, CBOR_DECODER_FINISHED,
313 decode(map_embedded_int8_data + 1, 2));
314
315 assert_uint8_eq(0);
316 assert_decoder_result(1, CBOR_DECODER_FINISHED,
317 decode(map_embedded_int8_data + 2, 1));
318 }
319
320 unsigned char map_int8_data[] = {0xB8, 0x01, 0x00, 0x01};
test_map_int8_decoding(void ** state)321 static void test_map_int8_decoding(void **state) {
322 assert_map_start(1);
323 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(map_int8_data, 4));
324
325 assert_uint8_eq(0);
326 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(map_int8_data + 2, 2));
327
328 assert_uint8_eq(1);
329 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(map_int8_data + 3, 1));
330 }
331
332 unsigned char map_int16_data[] = {0xB9, 0x00, 0x01, 0x00, 0x01};
test_map_int16_decoding(void ** state)333 static void test_map_int16_decoding(void **state) {
334 assert_map_start(1);
335 assert_decoder_result(3, CBOR_DECODER_FINISHED, decode(map_int16_data, 5));
336
337 assert_uint8_eq(0);
338 assert_decoder_result(1, CBOR_DECODER_FINISHED,
339 decode(map_int16_data + 3, 2));
340
341 assert_uint8_eq(1);
342 assert_decoder_result(1, CBOR_DECODER_FINISHED,
343 decode(map_int16_data + 4, 1));
344 }
345
346 unsigned char map_int32_data[] = {0xBA, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01};
test_map_int32_decoding(void ** state)347 static void test_map_int32_decoding(void **state) {
348 assert_map_start(1);
349 assert_decoder_result(5, CBOR_DECODER_FINISHED, decode(map_int32_data, 7));
350
351 assert_uint8_eq(0);
352 assert_decoder_result(1, CBOR_DECODER_FINISHED,
353 decode(map_int32_data + 5, 2));
354
355 assert_uint8_eq(1);
356 assert_decoder_result(1, CBOR_DECODER_FINISHED,
357 decode(map_int32_data + 6, 1));
358 }
359
360 unsigned char map_int64_data[] = {0xBB, 0x00, 0x00, 0x00, 0x00, 0x00,
361 0x00, 0x00, 0x01, 0x00, 0x01};
test_map_int64_decoding(void ** state)362 static void test_map_int64_decoding(void **state) {
363 assert_map_start(1);
364 assert_decoder_result(9, CBOR_DECODER_FINISHED, decode(map_int64_data, 11));
365
366 assert_uint8_eq(0);
367 assert_decoder_result(1, CBOR_DECODER_FINISHED,
368 decode(map_int64_data + 9, 2));
369
370 assert_uint8_eq(1);
371 assert_decoder_result(1, CBOR_DECODER_FINISHED,
372 decode(map_int64_data + 10, 1));
373 }
374
375 unsigned char indef_map_data_1[] = {0xBF, 0x00, 0x18, 0xFF, 0xFF};
test_indef_map_decoding_1(void ** state)376 static void test_indef_map_decoding_1(void **state) {
377 assert_indef_map_start();
378 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(indef_map_data_1, 5));
379
380 assert_uint8_eq(0);
381 assert_decoder_result(1, CBOR_DECODER_FINISHED,
382 decode(indef_map_data_1 + 1, 4));
383
384 assert_uint8_eq(255);
385 assert_decoder_result(2, CBOR_DECODER_FINISHED,
386 decode(indef_map_data_1 + 2, 3));
387
388 assert_indef_break();
389 assert_decoder_result(1, CBOR_DECODER_FINISHED,
390 decode(indef_map_data_1 + 4, 1));
391 }
392
393 unsigned char map_nedata[] = {0xBB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
394 0x00, 0x01, 0x19, 0x01, 0xf4, 0x01};
test_nedata_map_decoding(void ** state)395 static void test_nedata_map_decoding(void **state) {
396 assert_decoder_result_nedata(8, decode(map_nedata, 1));
397
398 assert_map_start(1);
399 assert_decoder_result(9, CBOR_DECODER_FINISHED, decode(map_nedata, 9));
400
401 assert_decoder_result_nedata(2, decode(map_nedata + 9, 1));
402
403 assert_uint16_eq(500);
404 assert_decoder_result(3, CBOR_DECODER_FINISHED, decode(map_nedata + 9, 3));
405
406 assert_uint8_eq(1);
407 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(map_nedata + 12, 1));
408 }
409
410 unsigned char embedded_tag_data[] = {0xC1};
test_embedded_tag_decoding(void ** state)411 static void test_embedded_tag_decoding(void **state) {
412 assert_tag_eq(1);
413 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(embedded_tag_data, 1));
414 }
415
416 unsigned char int8_tag_data[] = {0xD8, 0xFE};
test_int8_tag_decoding(void ** state)417 static void test_int8_tag_decoding(void **state) {
418 assert_tag_eq(254);
419 assert_decoder_result(2, CBOR_DECODER_FINISHED, decode(int8_tag_data, 2));
420 }
421
422 unsigned char int16_tag_data[] = {0xD9, 0xFE, 0xFD};
test_int16_tag_decoding(void ** state)423 static void test_int16_tag_decoding(void **state) {
424 assert_tag_eq(65277);
425 assert_decoder_result(3, CBOR_DECODER_FINISHED, decode(int16_tag_data, 3));
426 }
427
428 unsigned char int32_tag_data[] = {0xDA, 0xFE, 0xFD, 0xFC, 0xFB};
test_int32_tag_decoding(void ** state)429 static void test_int32_tag_decoding(void **state) {
430 assert_tag_eq(4278058235ULL);
431 assert_decoder_result(5, CBOR_DECODER_FINISHED, decode(int32_tag_data, 5));
432 }
433
434 unsigned char int64_tag_data[] = {0xDB, 0xFE, 0xFD, 0xFC, 0xFB,
435 0xFA, 0xF9, 0xF8, 0xF7};
test_int64_tag_decoding(void ** state)436 static void test_int64_tag_decoding(void **state) {
437 assert_tag_eq(18374120213919168759ULL);
438 assert_decoder_result(9, CBOR_DECODER_FINISHED, decode(int64_tag_data, 9));
439 }
440
441 unsigned char bad_tag_data[] = {0xC6};
test_bad_tag_decoding(void ** state)442 static void test_bad_tag_decoding(void **state) {
443 assert_decoder_result(0, CBOR_DECODER_ERROR, decode(bad_tag_data, 1));
444 }
445
446 unsigned char float2_data[] = {0xF9, 0x7B, 0xFF};
test_float2_decoding(void ** state)447 static void test_float2_decoding(void **state) {
448 assert_half(65504.0);
449 assert_decoder_result(3, CBOR_DECODER_FINISHED, decode(float2_data, 3));
450 }
451
452 unsigned char float4_data[] = {0xFA, 0x47, 0xC3, 0x50, 0x00};
test_float4_decoding(void ** state)453 static void test_float4_decoding(void **state) {
454 assert_float(100000.0);
455 assert_decoder_result(5, CBOR_DECODER_FINISHED, decode(float4_data, 5));
456 }
457
458 unsigned char float8_data[] = {0xFB, 0xC0, 0x10, 0x66, 0x66,
459 0x66, 0x66, 0x66, 0x66};
test_float8_decoding(void ** state)460 static void test_float8_decoding(void **state) {
461 assert_double(-4.1);
462 assert_decoder_result(9, CBOR_DECODER_FINISHED, decode(float8_data, 9));
463 }
464
465 unsigned char false_data[] = {0xF4};
test_false_decoding(void ** state)466 static void test_false_decoding(void **state) {
467 assert_bool(false);
468 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(false_data, 1));
469 }
470
471 unsigned char true_data[] = {0xF5};
test_true_decoding(void ** state)472 static void test_true_decoding(void **state) {
473 assert_bool(true);
474 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(true_data, 1));
475 }
476
477 unsigned char null_data[] = {0xF6};
test_null_decoding(void ** state)478 static void test_null_decoding(void **state) {
479 assert_nil();
480 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(null_data, 1));
481 }
482
483 unsigned char undef_data[] = {0xF7};
test_undef_decoding(void ** state)484 static void test_undef_decoding(void **state) {
485 assert_undef();
486 assert_decoder_result(1, CBOR_DECODER_FINISHED, decode(undef_data, 1));
487 }
488
main(void)489 int main(void) {
490 set_decoder(&cbor_stream_decode);
491 const struct CMUnitTest tests[] = {
492 cmocka_unit_test(test_uint8_embedded_decoding),
493 cmocka_unit_test(test_uint8_decoding),
494 cmocka_unit_test(test_uint16_decoding),
495 cmocka_unit_test(test_uint32_decoding),
496 cmocka_unit_test(test_uint64_decoding),
497
498 cmocka_unit_test(test_negint8_embedded_decoding),
499 cmocka_unit_test(test_negint8_decoding),
500 cmocka_unit_test(test_negint16_decoding),
501 cmocka_unit_test(test_negint32_decoding),
502 cmocka_unit_test(test_negint64_decoding),
503
504 cmocka_unit_test(test_bstring_embedded_int8_decoding),
505 cmocka_unit_test(test_bstring_int8_decoding),
506 cmocka_unit_test(test_bstring_int16_decoding),
507 cmocka_unit_test(test_bstring_int32_decoding),
508 #ifdef EIGHT_BYTE_SIZE_T
509 cmocka_unit_test(test_bstring_int64_decoding),
510 #endif
511 cmocka_unit_test(test_bstring_indef_decoding_1),
512 cmocka_unit_test(test_bstring_indef_decoding_2),
513 cmocka_unit_test(test_bstring_indef_decoding_3),
514
515 cmocka_unit_test(test_array_embedded_int8_decoding),
516 cmocka_unit_test(test_array_int8_decoding),
517 cmocka_unit_test(test_array_int16_decoding),
518 cmocka_unit_test(test_array_int32_decoding),
519 cmocka_unit_test(test_array_int64_decoding),
520 cmocka_unit_test(test_array_of_arrays_decoding),
521 cmocka_unit_test(test_indef_array_decoding_1),
522
523 cmocka_unit_test(test_map_embedded_int8_decoding),
524 cmocka_unit_test(test_map_int8_decoding),
525 cmocka_unit_test(test_map_int16_decoding),
526 cmocka_unit_test(test_map_int32_decoding),
527 cmocka_unit_test(test_map_int64_decoding),
528 cmocka_unit_test(test_indef_map_decoding_1),
529 cmocka_unit_test(test_nedata_map_decoding),
530
531 cmocka_unit_test(test_embedded_tag_decoding),
532 cmocka_unit_test(test_int8_tag_decoding),
533 cmocka_unit_test(test_int16_tag_decoding),
534 cmocka_unit_test(test_int32_tag_decoding),
535 cmocka_unit_test(test_int64_tag_decoding),
536 cmocka_unit_test(test_bad_tag_decoding),
537
538 cmocka_unit_test(test_float2_decoding),
539 cmocka_unit_test(test_float4_decoding),
540 cmocka_unit_test(test_float8_decoding),
541
542 cmocka_unit_test(test_false_decoding),
543 cmocka_unit_test(test_true_decoding),
544 cmocka_unit_test(test_null_decoding),
545 cmocka_unit_test(test_undef_decoding)};
546 return cmocka_run_group_tests(tests, NULL, NULL);
547 }
548