xref: /netbsd-src/external/mit/libcbor/dist/test/stream_expectations.c (revision 5dd36a3bc8bf2a9dec29ceb6349550414570c447)
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