1 #include "stream_expectations.h"
2
3 /* Ordered from 0 to queue_size - 1 */
4 struct test_assertion assertions_queue[MAX_QUEUE_ITEMS];
5 size_t queue_size = 0;
6 size_t current_expectation = 0;
7 decoder_t* decoder;
8
set_decoder(decoder_t * dec)9 void set_decoder(decoder_t* dec) { decoder = dec; }
10
11 /* Callbacks */
current()12 struct test_assertion current() {
13 return assertions_queue[current_expectation];
14 }
15
16 /* Assertions builders and matcher callbacks */
17
assert_uint8_eq(uint8_t actual)18 void assert_uint8_eq(uint8_t actual) {
19 assertions_queue[queue_size++] = (struct test_assertion){
20 UINT8_EQ, (union test_expectation_data){.int8 = actual}};
21 }
22
uint8_callback(void * context,uint8_t actual)23 void uint8_callback(void* context, uint8_t actual) {
24 assert_true(current().expectation == UINT8_EQ);
25 assert_true(current().data.int8 == actual);
26 current_expectation++;
27 }
28
assert_uint16_eq(uint16_t actual)29 void assert_uint16_eq(uint16_t actual) {
30 assertions_queue[queue_size++] = (struct test_assertion){
31 UINT16_EQ, (union test_expectation_data){.int16 = actual}};
32 }
33
uint16_callback(void * context,uint16_t actual)34 void uint16_callback(void* context, uint16_t actual) {
35 assert_true(current().expectation == UINT16_EQ);
36 assert_true(current().data.int16 == actual);
37 current_expectation++;
38 }
39
assert_uint32_eq(uint32_t actual)40 void assert_uint32_eq(uint32_t actual) {
41 assertions_queue[queue_size++] = (struct test_assertion){
42 UINT32_EQ, (union test_expectation_data){.int32 = actual}};
43 }
44
uint32_callback(void * context,uint32_t actual)45 void uint32_callback(void* context, uint32_t actual) {
46 assert_true(current().expectation == UINT32_EQ);
47 assert_true(current().data.int32 == actual);
48 current_expectation++;
49 }
50
assert_uint64_eq(uint64_t actual)51 void assert_uint64_eq(uint64_t actual) {
52 assertions_queue[queue_size++] = (struct test_assertion){
53 UINT64_EQ, (union test_expectation_data){.int64 = actual}};
54 }
55
uint64_callback(void * context,uint64_t actual)56 void uint64_callback(void* context, uint64_t actual) {
57 assert_true(current().expectation == UINT64_EQ);
58 assert_true(current().data.int64 == actual);
59 current_expectation++;
60 }
61
assert_negint8_eq(uint8_t actual)62 void assert_negint8_eq(uint8_t actual) {
63 assertions_queue[queue_size++] = (struct test_assertion){
64 NEGINT8_EQ, (union test_expectation_data){.int8 = actual}};
65 }
66
negint8_callback(void * context,uint8_t actual)67 void negint8_callback(void* context, uint8_t actual) {
68 assert_true(current().expectation == NEGINT8_EQ);
69 assert_true(current().data.int8 == actual);
70 current_expectation++;
71 }
72
assert_negint16_eq(uint16_t actual)73 void assert_negint16_eq(uint16_t actual) {
74 assertions_queue[queue_size++] = (struct test_assertion){
75 NEGINT16_EQ, (union test_expectation_data){.int16 = actual}};
76 }
77
negint16_callback(void * context,uint16_t actual)78 void negint16_callback(void* context, uint16_t actual) {
79 assert_true(current().expectation == NEGINT16_EQ);
80 assert_true(current().data.int16 == actual);
81 current_expectation++;
82 }
83
assert_negint32_eq(uint32_t actual)84 void assert_negint32_eq(uint32_t actual) {
85 assertions_queue[queue_size++] = (struct test_assertion){
86 NEGINT32_EQ, (union test_expectation_data){.int32 = actual}};
87 }
88
negint32_callback(void * context,uint32_t actual)89 void negint32_callback(void* context, uint32_t actual) {
90 assert_true(current().expectation == NEGINT32_EQ);
91 assert_true(current().data.int32 == actual);
92 current_expectation++;
93 }
94
assert_negint64_eq(uint64_t actual)95 void assert_negint64_eq(uint64_t actual) {
96 assertions_queue[queue_size++] = (struct test_assertion){
97 NEGINT64_EQ, (union test_expectation_data){.int64 = actual}};
98 }
99
negint64_callback(void * context,uint64_t actual)100 void negint64_callback(void* context, uint64_t actual) {
101 assert_true(current().expectation == NEGINT64_EQ);
102 assert_true(current().data.int64 == actual);
103 current_expectation++;
104 }
105
assert_bstring_mem_eq(cbor_data address,size_t length)106 void assert_bstring_mem_eq(cbor_data address, size_t length) {
107 assertions_queue[queue_size++] = (struct test_assertion){
108 BSTRING_MEM_EQ,
109 (union test_expectation_data){.string = {address, length}}};
110 }
111
byte_string_callback(void * context,cbor_data address,size_t length)112 void byte_string_callback(void* context, cbor_data address, size_t length) {
113 assert_true(current().expectation == BSTRING_MEM_EQ);
114 assert_true(current().data.string.address == address);
115 assert_true(current().data.string.length == length);
116 current_expectation++;
117 }
118
assert_bstring_indef_start()119 void assert_bstring_indef_start() {
120 assertions_queue[queue_size++] =
121 (struct test_assertion){.expectation = BSTRING_INDEF_START};
122 }
123
byte_string_start_callback(void * context)124 void byte_string_start_callback(void* context) {
125 assert_true(current().expectation == BSTRING_INDEF_START);
126 current_expectation++;
127 }
128
assert_indef_break()129 void assert_indef_break() {
130 assertions_queue[queue_size++] =
131 (struct test_assertion){.expectation = INDEF_BREAK};
132 }
133
indef_break_callback(void * context)134 void indef_break_callback(void* context) {
135 assert_true(current().expectation == INDEF_BREAK);
136 current_expectation++;
137 }
138
assert_array_start(size_t length)139 void assert_array_start(size_t length) {
140 assertions_queue[queue_size++] =
141 (struct test_assertion){ARRAY_START, {.length = length}};
142 }
143
array_start_callback(void * context,size_t length)144 void array_start_callback(void* context, size_t length) {
145 assert_true(current().expectation == ARRAY_START);
146 assert_true(current().data.length == length);
147 current_expectation++;
148 }
149
assert_indef_array_start()150 void assert_indef_array_start() {
151 assertions_queue[queue_size++] =
152 (struct test_assertion){.expectation = ARRAY_INDEF_START};
153 }
154
indef_array_start_callback(void * context)155 void indef_array_start_callback(void* context) {
156 assert_true(current().expectation == ARRAY_INDEF_START);
157 current_expectation++;
158 }
159
assert_map_start(size_t length)160 void assert_map_start(size_t length) {
161 assertions_queue[queue_size++] =
162 (struct test_assertion){MAP_START, {.length = length}};
163 }
164
map_start_callback(void * context,size_t length)165 void map_start_callback(void* context, size_t length) {
166 assert_true(current().expectation == MAP_START);
167 assert_true(current().data.length == length);
168 current_expectation++;
169 }
170
assert_indef_map_start()171 void assert_indef_map_start() {
172 assertions_queue[queue_size++] =
173 (struct test_assertion){.expectation = MAP_INDEF_START};
174 }
175
indef_map_start_callback(void * context)176 void indef_map_start_callback(void* context) {
177 assert_true(current().expectation == MAP_INDEF_START);
178 current_expectation++;
179 }
180
assert_tag_eq(uint64_t value)181 void assert_tag_eq(uint64_t value) {
182 assertions_queue[queue_size++] =
183 (struct test_assertion){TAG_EQ, {.int64 = value}};
184 }
185
tag_callback(void * context,uint64_t value)186 void tag_callback(void* context, uint64_t value) {
187 assert_true(current().expectation == TAG_EQ);
188 assert_true(current().data.int64 == value);
189 current_expectation++;
190 }
191
assert_half(float value)192 void assert_half(float value) {
193 assertions_queue[queue_size++] =
194 (struct test_assertion){HALF_EQ, {.float2 = value}};
195 }
196
half_callback(void * context,float actual)197 void half_callback(void* context, float actual) {
198 assert_true(current().expectation == HALF_EQ);
199 assert_true(current().data.float2 == actual);
200 current_expectation++;
201 }
202
assert_float(float value)203 void assert_float(float value) {
204 assertions_queue[queue_size++] =
205 (struct test_assertion){FLOAT_EQ, {.float4 = value}};
206 }
207
float_callback(void * context,float actual)208 void float_callback(void* context, float actual) {
209 assert_true(current().expectation == FLOAT_EQ);
210 assert_true(current().data.float4 == actual);
211 current_expectation++;
212 }
213
assert_double(double value)214 void assert_double(double value) {
215 assertions_queue[queue_size++] =
216 (struct test_assertion){DOUBLE_EQ, {.float8 = value}};
217 }
218
double_callback(void * context,double actual)219 void double_callback(void* context, double actual) {
220 assert_true(current().expectation == DOUBLE_EQ);
221 assert_true(current().data.float8 == actual);
222 current_expectation++;
223 }
224
assert_bool(bool value)225 void assert_bool(bool value) {
226 assertions_queue[queue_size++] =
227 (struct test_assertion){BOOL_EQ, {.boolean = value}};
228 }
229
assert_nil()230 void assert_nil() {
231 assertions_queue[queue_size++] = (struct test_assertion){.expectation = NIL};
232 }
233
assert_undef()234 void assert_undef() {
235 assertions_queue[queue_size++] =
236 (struct test_assertion){.expectation = UNDEF};
237 }
238
bool_callback(void * context,bool actual)239 void bool_callback(void* context, bool actual) {
240 assert_true(current().expectation == BOOL_EQ);
241 assert_true(current().data.boolean == actual);
242 current_expectation++;
243 }
244
null_callback(void * context)245 void null_callback(void* context) {
246 assert_true(current().expectation == NIL);
247 current_expectation++;
248 }
249
undef_callback(void * context)250 void undef_callback(void* context) {
251 assert_true(current().expectation == UNDEF);
252 current_expectation++;
253 }
254
255 const struct cbor_callbacks asserting_callbacks = {
256
257 .uint8 = &uint8_callback,
258
259 .uint16 = &uint16_callback,
260
261 .uint32 = &uint32_callback,
262
263 .uint64 = &uint64_callback,
264
265 .negint8 = &negint8_callback,
266
267 .negint16 = &negint16_callback,
268
269 .negint32 = &negint32_callback,
270
271 .negint64 = &negint64_callback,
272
273 .byte_string = &byte_string_callback,
274 .byte_string_start = &byte_string_start_callback,
275
276 .array_start = &array_start_callback,
277 .indef_array_start = &indef_array_start_callback,
278
279 .map_start = &map_start_callback,
280 .indef_map_start = &indef_map_start_callback,
281
282 .tag = &tag_callback,
283
284 .float2 = &half_callback,
285
286 .float4 = &float_callback,
287
288 .float8 = &double_callback,
289
290 .undefined = &undef_callback,
291 .boolean = &bool_callback,
292 .null = &null_callback,
293 .indef_break = &indef_break_callback};
294
decode(cbor_data source,size_t source_size)295 struct cbor_decoder_result decode(cbor_data source, size_t source_size) {
296 struct cbor_decoder_result result =
297 decoder(source, source_size, &asserting_callbacks, NULL);
298 /* Check remaining assertions */
299
300 assert_true(current_expectation == queue_size);
301 /* Clean up */
302 current_expectation = queue_size = 0;
303 return result;
304 }
305