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