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