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 "cbor.h"
15
16 cbor_item_t *bs;
17 struct cbor_load_result res;
18
19 unsigned char data1[] = {0x40, 0xFF};
20 unsigned char data2[] = {0x41, 0xA1};
21 unsigned char data3[] = {0x58, 0x01, 0xA1, 0xFF};
22 unsigned char data4[] = {
23 0x58, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
24 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
25 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21,
26 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,
27 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
28 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
29 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51,
30 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D,
31 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
32 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
33 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81,
34 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D,
35 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
36 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5,
37 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1,
38 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD,
39 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
40 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5,
41 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1,
42 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED,
43 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9,
44 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF};
45 unsigned char data5[] = {
46 0x59, 0x00, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
47 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14,
48 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
49 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C,
50 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
51 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44,
52 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
53 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C,
54 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
55 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74,
56 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80,
57 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C,
58 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
59 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4,
60 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0,
61 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC,
62 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
63 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
64 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0,
65 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC,
66 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
67 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF};
68 unsigned char data6[] = {
69 0x5A, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
70 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
71 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
72 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A,
73 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
74 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42,
75 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
76 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A,
77 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
78 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72,
79 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
80 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A,
81 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
82 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2,
83 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE,
84 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
85 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6,
86 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2,
87 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE,
88 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
89 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6,
90 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF};
91 unsigned char data7[] = {
92 0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x01, 0x02,
93 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
94 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A,
95 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
96 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32,
97 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E,
98 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
99 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
100 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62,
101 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
102 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
103 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86,
104 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
105 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E,
106 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA,
107 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
108 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2,
109 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE,
110 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
111 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
112 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2,
113 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE,
114 0xFF};
115 unsigned char data8[] = {
116 0x5C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xFF, 0x00, 0x01,
117 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
118 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
119 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
120 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31,
121 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,
122 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
123 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
124 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61,
125 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D,
126 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
127 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
128 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91,
129 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
130 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9,
131 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5,
132 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1,
133 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD,
134 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
135 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5,
136 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1,
137 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD,
138 0xFE, 0xFF};
139
test_empty_bs(void ** state)140 static void test_empty_bs(void **state) {
141 bs = cbor_load(data1, 2, &res);
142 assert_non_null(bs);
143 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
144 assert_true(cbor_isa_bytestring(bs));
145 assert_int_equal(cbor_bytestring_length(bs), 0);
146 assert_true(res.read == 1);
147 cbor_decref(&bs);
148 assert_null(bs);
149 }
150
test_embedded_bs(void ** state)151 static void test_embedded_bs(void **state) {
152 bs = cbor_load(data2, 2, &res);
153 assert_non_null(bs);
154 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
155 assert_true(cbor_isa_bytestring(bs));
156 assert_true(cbor_bytestring_length(bs) == 1);
157 assert_true(res.read == 2);
158 assert_true(*cbor_bytestring_handle(bs) == 0xA1);
159 assert_memory_equal(cbor_bytestring_handle(bs), data2 + 1, 1);
160 cbor_decref(&bs);
161 assert_null(bs);
162 }
163
test_notenough_data(void ** state)164 static void test_notenough_data(void **state) {
165 bs = cbor_load(data3, 2, &res);
166 assert_null(bs);
167 assert_true(res.error.code == CBOR_ERR_NOTENOUGHDATA);
168 }
169
test_short_bs1(void ** state)170 static void test_short_bs1(void **state) {
171 bs = cbor_load(data3, 4, &res);
172 assert_non_null(bs);
173 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
174 assert_true(cbor_isa_bytestring(bs));
175 assert_true(cbor_bytestring_length(bs) == 1);
176 assert_true(res.read == 3);
177 assert_true(*cbor_bytestring_handle(bs) == 0xA1);
178 assert_memory_equal(cbor_bytestring_handle(bs), data3 + 2, 1);
179 cbor_decref(&bs);
180 assert_null(bs);
181 }
182
test_short_bs2(void ** state)183 static void test_short_bs2(void **state) {
184 bs = cbor_load(data4, 259, &res);
185 assert_non_null(bs);
186 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
187 assert_true(cbor_isa_bytestring(bs));
188 assert_true(cbor_bytestring_length(bs) == 255);
189 assert_true(res.read == 257);
190 assert_memory_equal(cbor_bytestring_handle(bs), data4 + 2, 0xFF);
191 cbor_decref(&bs);
192 assert_null(bs);
193 }
194
test_half_bs(void ** state)195 static void test_half_bs(void **state) {
196 bs = cbor_load(data5, 259, &res);
197 assert_non_null(bs);
198 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
199 assert_true(cbor_isa_bytestring(bs));
200 assert_true(cbor_bytestring_length(bs) == 255);
201 assert_true(res.read == 258);
202 assert_memory_equal(cbor_bytestring_handle(bs), data5 + 3, 0xFF);
203 cbor_decref(&bs);
204 assert_null(bs);
205 }
206
test_int_bs(void ** state)207 static void test_int_bs(void **state) {
208 bs = cbor_load(data6, 261, &res);
209 assert_non_null(bs);
210 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
211 assert_true(cbor_isa_bytestring(bs));
212 assert_true(cbor_bytestring_length(bs) == 255);
213 assert_true(res.read == 260);
214 assert_memory_equal(cbor_bytestring_handle(bs), data6 + 5, 0xFF);
215 cbor_decref(&bs);
216 assert_null(bs);
217 }
218
test_long_bs(void ** state)219 static void test_long_bs(void **state) {
220 bs = cbor_load(data7, 265, &res);
221 assert_non_null(bs);
222 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
223 assert_true(cbor_isa_bytestring(bs));
224 assert_true(cbor_bytestring_length(bs) == 255);
225 assert_true(res.read == 264);
226 assert_memory_equal(cbor_bytestring_handle(bs), data7 + 9, 0xFF);
227 cbor_decref(&bs);
228 assert_null(bs);
229 }
230
231 unsigned char data9[] = {0x5F, 0xFF};
232
test_zero_indef(void ** state)233 static void test_zero_indef(void **state) {
234 bs = cbor_load(data9, 2, &res);
235 assert_non_null(bs);
236 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
237 assert_true(cbor_isa_bytestring(bs));
238 assert_true(cbor_bytestring_is_indefinite(bs));
239 assert_true(cbor_bytestring_chunk_count(bs) == 0);
240 assert_true(res.read == 2);
241 cbor_decref(&bs);
242 assert_null(bs);
243 }
244
245 unsigned char data10[] = {0x5F, 0x58, 0x01, 0xA1, 0xFF, 0xFF};
246
247 /* start | bstring | break| extra */
248
test_short_indef(void ** state)249 static void test_short_indef(void **state) {
250 bs = cbor_load(data10, 6, &res);
251 assert_non_null(bs);
252 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
253 assert_true(cbor_isa_bytestring(bs));
254 assert_true(cbor_bytestring_length(bs) == 0);
255 assert_true(cbor_bytestring_is_indefinite(bs));
256 assert_true(cbor_bytestring_chunk_count(bs) == 1);
257 assert_true(res.read == 5);
258 assert_true(cbor_isa_bytestring(cbor_bytestring_chunks_handle(bs)[0]));
259 assert_true(cbor_bytestring_length(cbor_bytestring_chunks_handle(bs)[0]) ==
260 1);
261 assert_true(*cbor_bytestring_handle(cbor_bytestring_chunks_handle(bs)[0]) ==
262 0xA1);
263 cbor_decref(&bs);
264 assert_null(bs);
265 }
266
267 unsigned char data11[] = {0x5F, 0x58, 0x01, 0xA1, 0x58, 0x01, 0xA2, 0xFF, 0xFF};
268
269 /* start | bstring | bstring | break|
270 * extra */
271
test_two_indef(void ** state)272 static void test_two_indef(void **state) {
273 bs = cbor_load(data11, 9, &res);
274 assert_non_null(bs);
275 assert_int_equal(1, cbor_refcount(bs));
276 assert_true(cbor_typeof(bs) == CBOR_TYPE_BYTESTRING);
277 assert_true(cbor_isa_bytestring(bs));
278 assert_true(cbor_bytestring_length(bs) == 0);
279 assert_true(cbor_bytestring_is_indefinite(bs));
280 assert_true(cbor_bytestring_chunk_count(bs) == 2);
281 assert_true(res.read == 8);
282 assert_true(cbor_isa_bytestring(cbor_bytestring_chunks_handle(bs)[0]));
283 assert_true(cbor_bytestring_length(cbor_bytestring_chunks_handle(bs)[0]) ==
284 1);
285 assert_true(*cbor_bytestring_handle(cbor_bytestring_chunks_handle(bs)[0]) ==
286 0xA1);
287 assert_true(cbor_isa_bytestring(cbor_bytestring_chunks_handle(bs)[1]));
288 assert_true(cbor_bytestring_length(cbor_bytestring_chunks_handle(bs)[1]) ==
289 1);
290 assert_true(*cbor_bytestring_handle(cbor_bytestring_chunks_handle(bs)[1]) ==
291 0xA2);
292 cbor_decref(&bs);
293 assert_null(bs);
294 }
295
296 unsigned char data12[] = {0x5F, 0x58, 0x01};
297
298 /* start | bstring - too short */
299
test_missing_indef(void ** state)300 static void test_missing_indef(void **state) {
301 bs = cbor_load(data12, 3, &res);
302 assert_true(res.error.code == CBOR_ERR_NOTENOUGHDATA);
303 assert_null(bs);
304 }
305
test_inline_creation(void ** state)306 static void test_inline_creation(void **state) {
307 bs = cbor_build_bytestring((cbor_data) "Hello!", 6);
308 assert_memory_equal(cbor_bytestring_handle(bs), "Hello!", 6);
309 cbor_decref(&bs);
310 }
311
main(void)312 int main(void) {
313 const struct CMUnitTest tests[] = {cmocka_unit_test(test_empty_bs),
314 cmocka_unit_test(test_embedded_bs),
315 cmocka_unit_test(test_notenough_data),
316 cmocka_unit_test(test_short_bs1),
317 cmocka_unit_test(test_short_bs2),
318 cmocka_unit_test(test_half_bs),
319 cmocka_unit_test(test_int_bs),
320 cmocka_unit_test(test_long_bs),
321 cmocka_unit_test(test_zero_indef),
322 cmocka_unit_test(test_short_indef),
323 cmocka_unit_test(test_two_indef),
324 cmocka_unit_test(test_missing_indef),
325 cmocka_unit_test(test_inline_creation)};
326 return cmocka_run_group_tests(tests, NULL, NULL);
327 }
328