1 /* 2 * Copyright (c) 2014-2019 Pavel Kalvoda <me (at) 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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] */}; 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] */}; 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] */}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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}; 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 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
Indexes created Sat Feb 28 05:31:39 UTC 2026