Greenbone Vulnerability Management Libraries 22.32.0
jsonpull_tests.c
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2019-2023 Greenbone AG
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later
4 */
5
6#include "json.c"
7#include "jsonpull.c"
8
9#include <cgreen/cgreen.h>
10#include <cgreen/mocks.h>
11#include <stdio.h>
12
13Describe (jsonpull);
14BeforeEach (jsonpull)
15{
16}
17AfterEach (jsonpull)
18{
19}
20
21/*
22 * Helper function to open a string as a read-only stream.
23 */
24static inline FILE *
25fstropen_r (const char *str)
26{
27 return fmemopen ((void *) str, strlen (str), "r");
28}
29
30static ssize_t
31read_with_error_on_eof (void *stream_cookie, char *buf, size_t size)
32{
33 FILE *stream = stream_cookie;
34 ssize_t ret = fread (buf, 1, size, stream);
35 if (ret <= 0)
36 {
37 errno = EIO;
38 return -1;
39 }
40 else
41 return ret;
42}
43
44#define INIT_JSON_PARSER(json_string) \
45 gvm_json_pull_event_t event; \
46 gvm_json_pull_parser_t parser; \
47 FILE *jsonstream; \
48 jsonstream = fstropen_r (json_string); \
49 gvm_json_pull_event_init (&event); \
50 gvm_json_pull_parser_init_full (&parser, jsonstream, 100, 4);
51
52#define INIT_READ_ERROR_JSON_PARSER(json_string) \
53 gvm_json_pull_event_t event; \
54 gvm_json_pull_parser_t parser; \
55 FILE *jsonstream = fstropen_r (json_string); \
56 cookie_io_functions_t io_functions = {.read = read_with_error_on_eof, \
57 .write = NULL, \
58 .seek = NULL, \
59 .close = NULL}; \
60 FILE *errorstream = fopencookie (jsonstream, "r", io_functions); \
61 gvm_json_pull_event_init (&event); \
62 gvm_json_pull_parser_init_full (&parser, errorstream, 100, 4);
63
64#define CLEANUP_JSON_PARSER \
65 gvm_json_pull_event_cleanup (&event); \
66 gvm_json_pull_parser_cleanup (&parser); \
67 fclose (jsonstream);
68
69#define CHECK_PATH_EQUALS(expected_path_str) \
70 path_str = gvm_json_path_to_string (event.path); \
71 assert_that (path_str, is_equal_to_string (expected_path_str)); \
72 g_free (path_str);
73
74#define JSON_READ_ERROR "error reading JSON stream: Input/output error"
75
76Ensure (jsonpull, can_init_parser_with_defaults)
77{
78 gvm_json_pull_parser_t parser;
79 FILE *strfile = fstropen_r ("[]");
80
81 gvm_json_pull_parser_init (&parser, strfile);
82 assert_that (parser.input_stream, is_equal_to (strfile));
83 assert_that (parser.parse_buffer_limit,
84 is_equal_to (GVM_JSON_PULL_PARSE_BUFFER_LIMIT));
85 assert_that (parser.read_buffer_size,
86 is_equal_to (GVM_JSON_PULL_READ_BUFFER_SIZE));
87 gvm_json_pull_parser_cleanup (&parser);
88}
89
90Ensure (jsonpull, can_parse_false)
91{
92 INIT_JSON_PARSER ("false");
93
94 gvm_json_pull_parser_next (&parser, &event);
95 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_BOOLEAN));
96 assert_that (cJSON_IsBool (event.value), is_true);
97 assert_that (cJSON_IsFalse (event.value), is_true);
98
99 gvm_json_pull_parser_next (&parser, &event);
100 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
101 CLEANUP_JSON_PARSER;
102}
103
104Ensure (jsonpull, can_parse_true)
105{
106 INIT_JSON_PARSER ("true");
107
108 gvm_json_pull_parser_next (&parser, &event);
109 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_BOOLEAN));
110 assert_that (cJSON_IsBool (event.value), is_true);
111 assert_that (cJSON_IsTrue (event.value), is_true);
112
113 gvm_json_pull_parser_next (&parser, &event);
114 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
115 CLEANUP_JSON_PARSER;
116}
117
118Ensure (jsonpull, can_parse_null)
119{
120 INIT_JSON_PARSER ("null");
121
122 gvm_json_pull_parser_next (&parser, &event);
123 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NULL));
124 assert_that (cJSON_IsNull (event.value), is_true);
125
126 gvm_json_pull_parser_next (&parser, &event);
127 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
128 CLEANUP_JSON_PARSER;
129}
130
131Ensure (jsonpull, can_parse_empty_strings)
132{
133 INIT_JSON_PARSER ("\"\"");
134
135 gvm_json_pull_parser_next (&parser, &event);
136 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_STRING));
137 assert_that (event.value->valuestring, is_equal_to_string (""));
138
139 gvm_json_pull_parser_next (&parser, &event);
140 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
141 CLEANUP_JSON_PARSER;
142}
143
144Ensure (jsonpull, can_parse_strings_with_content)
145{
146 INIT_JSON_PARSER ("\n\"123\\tXYZ\\nÄöü\"\n");
147
148 gvm_json_pull_parser_next (&parser, &event);
149 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_STRING));
150 assert_that (event.value->valuestring, is_equal_to_string ("123\tXYZ\nÄöü"));
151
152 gvm_json_pull_parser_next (&parser, &event);
153 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
154 CLEANUP_JSON_PARSER;
155}
156
157Ensure (jsonpull, can_parse_integer_numbers)
158{
159 INIT_JSON_PARSER ("-0987");
160
161 gvm_json_pull_parser_next (&parser, &event);
162 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
163 assert_that (event.value->valueint, is_equal_to (-987));
164
165 gvm_json_pull_parser_next (&parser, &event);
166 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
167 CLEANUP_JSON_PARSER;
168}
169
170Ensure (jsonpull, can_parse_floating_point_numbers)
171{
172 INIT_JSON_PARSER ("\t\n 1.2345e+4\n");
173
174 gvm_json_pull_parser_next (&parser, &event);
175 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
176 assert_that (event.value->valuedouble, is_equal_to (1.2345e+4));
177
178 gvm_json_pull_parser_next (&parser, &event);
179 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
180 CLEANUP_JSON_PARSER;
181}
182
183Ensure (jsonpull, can_parse_empty_arrays)
184{
185 INIT_JSON_PARSER ("[ ]");
186
187 gvm_json_pull_parser_next (&parser, &event);
188 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
189
190 gvm_json_pull_parser_next (&parser, &event);
191 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_END));
192
193 gvm_json_pull_parser_next (&parser, &event);
194 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
195 CLEANUP_JSON_PARSER;
196}
197
198Ensure (jsonpull, can_parse_single_elem_arrays)
199{
200 gchar *path_str;
201 INIT_JSON_PARSER ("[ 123 ]");
202
203 gvm_json_pull_parser_next (&parser, &event);
204 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
205
206 gvm_json_pull_parser_next (&parser, &event);
207 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
208 assert_that (event.value->valueint, is_equal_to (123));
209 CHECK_PATH_EQUALS ("$[0]");
210
211 gvm_json_pull_parser_next (&parser, &event);
212 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_END));
213
214 gvm_json_pull_parser_next (&parser, &event);
215 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
216 CLEANUP_JSON_PARSER;
217}
218
219Ensure (jsonpull, can_parse_multiple_elem_arrays)
220{
221 gchar *path_str;
222 INIT_JSON_PARSER ("[123, \"ABC\", null]");
223
224 gvm_json_pull_parser_next (&parser, &event);
225 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
226
227 gvm_json_pull_parser_next (&parser, &event);
228 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
229 assert_that (event.value->valueint, is_equal_to (123));
230 CHECK_PATH_EQUALS ("$[0]");
231
232 gvm_json_pull_parser_next (&parser, &event);
233 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_STRING));
234 assert_that (event.value->valuestring, is_equal_to_string ("ABC"));
235 CHECK_PATH_EQUALS ("$[1]");
236
237 gvm_json_pull_parser_next (&parser, &event);
238 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NULL));
239 CHECK_PATH_EQUALS ("$[2]");
240
241 gvm_json_pull_parser_next (&parser, &event);
242 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_END));
243
244 gvm_json_pull_parser_next (&parser, &event);
245 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
246 CLEANUP_JSON_PARSER;
247}
248
249Ensure (jsonpull, can_parse_empty_objects)
250{
251 INIT_JSON_PARSER ("{ }");
252
253 gvm_json_pull_parser_next (&parser, &event);
254 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
255
256 gvm_json_pull_parser_next (&parser, &event);
257 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_END));
258
259 gvm_json_pull_parser_next (&parser, &event);
260 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
261 CLEANUP_JSON_PARSER;
262}
263
264Ensure (jsonpull, can_parse_single_elem_objects)
265{
266 gchar *path_str;
267 INIT_JSON_PARSER ("{ \"keyA\": \"valueA\" }");
268
269 gvm_json_pull_parser_next (&parser, &event);
270 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
271
272 gvm_json_pull_parser_next (&parser, &event);
273 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_STRING));
274 assert_that (event.value->valuestring, is_equal_to_string ("valueA"));
275 CHECK_PATH_EQUALS ("$['keyA']");
276
277 gvm_json_pull_parser_next (&parser, &event);
278 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_END));
279
280 gvm_json_pull_parser_next (&parser, &event);
281 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
282 CLEANUP_JSON_PARSER;
283}
284
285Ensure (jsonpull, can_parse_multiple_elem_objects)
286{
287 gchar *path_str;
288 INIT_JSON_PARSER ("{ \"keyA\": \"valueA\", \"keyB\":12345 }");
289
290 gvm_json_pull_parser_next (&parser, &event);
291 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
292
293 gvm_json_pull_parser_next (&parser, &event);
294 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_STRING));
295 assert_that (event.value->valuestring, is_equal_to_string ("valueA"));
296 CHECK_PATH_EQUALS ("$['keyA']");
297
298 gvm_json_pull_parser_next (&parser, &event);
299 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
300 assert_that (event.value->valueint, is_equal_to (12345));
301 CHECK_PATH_EQUALS ("$['keyB']");
302
303 gvm_json_pull_parser_next (&parser, &event);
304 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_END));
305
306 gvm_json_pull_parser_next (&parser, &event);
307 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
308 CLEANUP_JSON_PARSER;
309}
310
311Ensure (jsonpull, can_parse_nested_containers)
312{
313 gchar *path_str;
314 INIT_JSON_PARSER ("[{\"A\":null, \"B\":{\"C\": [1,2]}, \"D\":\"3\"}, [4]]");
315
316 gvm_json_pull_parser_next (&parser, &event);
317 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
318 CHECK_PATH_EQUALS ("$");
319
320 gvm_json_pull_parser_next (&parser, &event);
321 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
322 CHECK_PATH_EQUALS ("$[0]");
323
324 gvm_json_pull_parser_next (&parser, &event);
325 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NULL));
326 CHECK_PATH_EQUALS ("$[0]['A']");
327
328 gvm_json_pull_parser_next (&parser, &event);
329 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
330 CHECK_PATH_EQUALS ("$[0]['B']");
331
332 gvm_json_pull_parser_next (&parser, &event);
333 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
334 CHECK_PATH_EQUALS ("$[0]['B']['C']");
335
336 gvm_json_pull_parser_next (&parser, &event);
337 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
338 assert_that (event.value->valueint, is_equal_to (1));
339 CHECK_PATH_EQUALS ("$[0]['B']['C'][0]");
340
341 gvm_json_pull_parser_next (&parser, &event);
342 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
343 assert_that (event.value->valueint, is_equal_to (2));
344 CHECK_PATH_EQUALS ("$[0]['B']['C'][1]");
345
346 gvm_json_pull_parser_next (&parser, &event);
347 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_END));
348 CHECK_PATH_EQUALS ("$[0]['B']['C']");
349
350 gvm_json_pull_parser_next (&parser, &event);
351 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_END));
352 CHECK_PATH_EQUALS ("$[0]['B']");
353
354 gvm_json_pull_parser_next (&parser, &event);
355 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_STRING));
356 assert_that (event.value->valuestring, is_equal_to_string ("3"));
357 CHECK_PATH_EQUALS ("$[0]['D']");
358
359 gvm_json_pull_parser_next (&parser, &event);
360 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_END));
361 CHECK_PATH_EQUALS ("$[0]");
362
363 gvm_json_pull_parser_next (&parser, &event);
364 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
365 CHECK_PATH_EQUALS ("$[1]");
366
367 gvm_json_pull_parser_next (&parser, &event);
368 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
369 assert_that (event.value->valueint, is_equal_to (4));
370 CHECK_PATH_EQUALS ("$[1][0]");
371
372 gvm_json_pull_parser_next (&parser, &event);
373 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_END));
374 CHECK_PATH_EQUALS ("$[1]");
375
376 gvm_json_pull_parser_next (&parser, &event);
377 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_END));
378 CHECK_PATH_EQUALS ("$");
379
380 gvm_json_pull_parser_next (&parser, &event);
381 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
382 CLEANUP_JSON_PARSER;
383}
384
385Ensure (jsonpull, can_expand_arrays)
386{
387 gchar *path_str, *error_message;
388 cJSON *expanded, *child;
389 INIT_JSON_PARSER ("[[], [1], [2, [3]], [\"A\", \"\\\"B]\"]]");
390
391 gvm_json_pull_parser_next (&parser, &event);
392 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
393 CHECK_PATH_EQUALS ("$");
394
395 // empty array
396 gvm_json_pull_parser_next (&parser, &event);
397 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
398 CHECK_PATH_EQUALS ("$[0]");
399 expanded = gvm_json_pull_expand_container (&parser, &error_message);
400 assert_that (error_message, is_equal_to_string (NULL));
401 assert_that (expanded, is_not_null);
402 assert_that (cJSON_IsArray (expanded), is_true);
403 assert_that (expanded->child, is_null);
404 cJSON_Delete (expanded);
405
406 // single-element array
407 gvm_json_pull_parser_next (&parser, &event);
408 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
409 CHECK_PATH_EQUALS ("$[1]");
410 expanded = gvm_json_pull_expand_container (&parser, &error_message);
411 assert_that (error_message, is_null);
412 assert_that (expanded, is_not_null);
413 assert_that (cJSON_IsArray (expanded), is_true);
414 child = expanded->child;
415 assert_that (child, is_not_null);
416 assert_that (cJSON_IsNumber (child), is_true);
417 assert_that (child->valueint, is_equal_to (1));
418 child = child->next;
419 assert_that (child, is_null);
420 cJSON_Delete (expanded);
421
422 // multi-element array
423 gvm_json_pull_parser_next (&parser, &event);
424 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
425 CHECK_PATH_EQUALS ("$[2]");
426 expanded = gvm_json_pull_expand_container (&parser, &error_message);
427 assert_that (error_message, is_null);
428 assert_that (expanded, is_not_null);
429 assert_that (cJSON_IsArray (expanded), is_true);
430 child = expanded->child;
431 assert_that (child, is_not_null);
432 assert_that (cJSON_IsNumber (child), is_true);
433 assert_that (child->valueint, is_equal_to (2));
434 child = child->next;
435 assert_that (child, is_not_null);
436 assert_that (cJSON_IsArray (child), is_true);
437 assert_that (child->child->valueint, is_equal_to (3));
438 cJSON_Delete (expanded);
439
440 // string array
441 gvm_json_pull_parser_next (&parser, &event);
442 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
443 CHECK_PATH_EQUALS ("$[3]");
444 expanded = gvm_json_pull_expand_container (&parser, &error_message);
445 assert_that (error_message, is_null);
446 assert_that (expanded, is_not_null);
447 assert_that (cJSON_IsArray (expanded), is_true);
448 child = expanded->child;
449 assert_that (child, is_not_null);
450 assert_that (cJSON_IsString (child), is_true);
451 assert_that (child->valuestring, is_equal_to_string ("A"));
452 child = child->next;
453 assert_that (child, is_not_null);
454 assert_that (cJSON_IsString (child), is_true);
455 assert_that (child->valuestring, is_equal_to_string ("\"B]"));
456 cJSON_Delete (expanded);
457
458 // array end and EOF
459 gvm_json_pull_parser_next (&parser, &event);
460 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_END));
461 CHECK_PATH_EQUALS ("$");
462
463 gvm_json_pull_parser_next (&parser, &event);
464 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
465 CLEANUP_JSON_PARSER;
466}
467
468Ensure (jsonpull, can_expand_objects)
469{
470 gchar *path_str, *error_message;
471 cJSON *expanded, *child;
472 INIT_JSON_PARSER (
473 "{\"A\":{}, \"B\": {\"C\": \"\\\"D}\", \"E\":123, \"F\":{}}}");
474
475 gvm_json_pull_parser_next (&parser, &event);
476 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
477 CHECK_PATH_EQUALS ("$");
478
479 gvm_json_pull_parser_next (&parser, &event);
480 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
481 CHECK_PATH_EQUALS ("$['A']");
482 expanded = gvm_json_pull_expand_container (&parser, &error_message);
483 assert_that (error_message, is_null);
484 assert_that (cJSON_IsObject (expanded), is_true);
485 assert_that (expanded->child, is_null);
486 cJSON_Delete (expanded);
487
488 gvm_json_pull_parser_next (&parser, &event);
489 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
490 CHECK_PATH_EQUALS ("$['B']");
491 expanded = gvm_json_pull_expand_container (&parser, &error_message);
492 assert_that (error_message, is_null);
493 assert_that (cJSON_IsObject (expanded), is_true);
494 child = expanded->child;
495 assert_that (child, is_not_null);
496 assert_that (cJSON_IsString (child), is_true);
497 assert_that (child->string, is_equal_to_string ("C"));
498 assert_that (child->valuestring, is_equal_to_string ("\"D}"));
499 child = child->next;
500 assert_that (child, is_not_null);
501 assert_that (cJSON_IsNumber (child), is_true);
502 assert_that (child->string, is_equal_to_string ("E"));
503 assert_that (child->valueint, is_equal_to (123));
504 child = child->next;
505 assert_that (child, is_not_null);
506 assert_that (cJSON_IsObject (child), is_true);
507 assert_that (child->string, is_equal_to_string ("F"));
508 assert_that (child->child, is_null);
509 cJSON_Delete (expanded);
510
511 // object end and EOF
512 gvm_json_pull_parser_next (&parser, &event);
513 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_END));
514 CHECK_PATH_EQUALS ("$");
515
516 gvm_json_pull_parser_next (&parser, &event);
517 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_EOF));
518 CLEANUP_JSON_PARSER;
519}
520
521Ensure (jsonpull, fails_for_read_error)
522{
523 INIT_READ_ERROR_JSON_PARSER ("123");
524
525 gvm_json_pull_parser_next (&parser, &event);
526 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
527 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
528 gvm_json_pull_parser_cleanup (&parser);
529 gvm_json_pull_event_cleanup (&event);
530 fclose (jsonstream);
531}
532
533Ensure (jsonpull, fails_for_misspelled_true)
534{
535 INIT_JSON_PARSER ("trxyz");
536
537 gvm_json_pull_parser_next (&parser, &event);
538 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
539 assert_that (event.error_message,
540 is_equal_to_string ("misspelled keyword 'true'"));
541 CLEANUP_JSON_PARSER;
542}
543
544Ensure (jsonpull, fails_for_incomplete_true)
545{
546 INIT_JSON_PARSER ("tru");
547
548 gvm_json_pull_parser_next (&parser, &event);
549 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
550 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
551 CLEANUP_JSON_PARSER;
552}
553
554Ensure (jsonpull, fails_for_misspelled_false)
555{
556 INIT_JSON_PARSER ("falxyz");
557
558 gvm_json_pull_parser_next (&parser, &event);
559 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
560 assert_that (event.error_message,
561 is_equal_to_string ("misspelled keyword 'false'"));
562 CLEANUP_JSON_PARSER;
563}
564
565Ensure (jsonpull, fails_for_misspelled_null)
566{
567 INIT_JSON_PARSER ("nulx");
568
569 gvm_json_pull_parser_next (&parser, &event);
570 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
571 assert_that (event.error_message,
572 is_equal_to_string ("misspelled keyword 'null'"));
573 CLEANUP_JSON_PARSER;
574}
575
576Ensure (jsonpull, fails_for_string_read_error)
577{
578 INIT_READ_ERROR_JSON_PARSER ("\"ABCDEFG\"");
579
580 gvm_json_pull_parser_next (&parser, &event);
581 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
582 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
583 CLEANUP_JSON_PARSER;
584}
585
586Ensure (jsonpull, fails_for_string_eof)
587{
588 INIT_JSON_PARSER ("\"no closing quote here");
589
590 gvm_json_pull_parser_next (&parser, &event);
591 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
592 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
593 CLEANUP_JSON_PARSER;
594}
595
596Ensure (jsonpull, fails_for_overlong_string)
597{
598 INIT_JSON_PARSER ("\"This should be too long for a small parse buffer\"");
599 parser.parse_buffer_limit = 10;
600
601 gvm_json_pull_parser_next (&parser, &event);
602 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
603 assert_that (event.error_message,
604 is_equal_to_string ("string exceeds size limit of 10 bytes"));
605 CLEANUP_JSON_PARSER;
606}
607
608Ensure (jsonpull, fails_for_invalid_string)
609{
610 INIT_JSON_PARSER ("\"This has an invalid escape sequence: \\x\"");
611
612 gvm_json_pull_parser_next (&parser, &event);
613 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
614 assert_that (event.error_message,
615 is_equal_to_string ("error parsing string"));
616 CLEANUP_JSON_PARSER;
617}
618
619Ensure (jsonpull, fails_for_number_read_error)
620{
621 INIT_READ_ERROR_JSON_PARSER ("12345.123456789");
622
623 gvm_json_pull_parser_next (&parser, &event);
624 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
625 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
626 CLEANUP_JSON_PARSER;
627}
628
629Ensure (jsonpull, fails_for_overlong_number)
630{
631 INIT_READ_ERROR_JSON_PARSER ("12345.123456789");
632 parser.parse_buffer_limit = 10;
633
634 gvm_json_pull_parser_next (&parser, &event);
635 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
636 assert_that (event.error_message,
637 is_equal_to_string ("number exceeds size limit of 10 bytes"));
638 CLEANUP_JSON_PARSER;
639}
640
641Ensure (jsonpull, fails_for_invalid_number)
642{
643 INIT_JSON_PARSER ("-+e");
644
645 gvm_json_pull_parser_next (&parser, &event);
646 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
647 assert_that (event.error_message,
648 is_equal_to_string ("error parsing number"));
649 CLEANUP_JSON_PARSER;
650}
651
652Ensure (jsonpull, fails_for_array_eof)
653{
654 INIT_JSON_PARSER ("[");
655
656 gvm_json_pull_parser_next (&parser, &event);
657 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
658 gvm_json_pull_parser_next (&parser, &event);
659 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
660 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
661 CLEANUP_JSON_PARSER;
662}
663
664Ensure (jsonpull, fails_for_array_eof_after_value)
665{
666 INIT_JSON_PARSER ("[123");
667
668 gvm_json_pull_parser_next (&parser, &event);
669 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
670 gvm_json_pull_parser_next (&parser, &event);
671 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
672 gvm_json_pull_parser_next (&parser, &event);
673 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
674 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
675 CLEANUP_JSON_PARSER;
676}
677
678Ensure (jsonpull, fails_for_array_eof_after_comma)
679{
680 INIT_JSON_PARSER ("[123,");
681
682 gvm_json_pull_parser_next (&parser, &event);
683 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
684 gvm_json_pull_parser_next (&parser, &event);
685 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
686 gvm_json_pull_parser_next (&parser, &event);
687 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
688 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
689 CLEANUP_JSON_PARSER;
690}
691
692Ensure (jsonpull, fails_for_array_read_error)
693{
694 INIT_READ_ERROR_JSON_PARSER ("[ ");
695
696 gvm_json_pull_parser_next (&parser, &event);
697 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
698 gvm_json_pull_parser_next (&parser, &event);
699 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
700 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
701 CLEANUP_JSON_PARSER;
702}
703
704Ensure (jsonpull, fails_for_invalid_array_bracket)
705{
706 INIT_JSON_PARSER ("[}");
707
708 gvm_json_pull_parser_next (&parser, &event);
709 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
710 gvm_json_pull_parser_next (&parser, &event);
711 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
712 assert_that (event.error_message,
713 is_equal_to_string ("unexpected closing curly brace"));
714 CLEANUP_JSON_PARSER;
715}
716
717Ensure (jsonpull, fails_for_invalid_array_bracket_after_value)
718{
719 INIT_JSON_PARSER ("[123}");
720
721 gvm_json_pull_parser_next (&parser, &event);
722 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
723 gvm_json_pull_parser_next (&parser, &event);
724 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
725 gvm_json_pull_parser_next (&parser, &event);
726 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
727 assert_that (event.error_message,
728 is_equal_to_string ("unexpected closing curly brace"));
729 CLEANUP_JSON_PARSER;
730}
731
732Ensure (jsonpull, fails_for_invalid_array_other_char)
733{
734 INIT_JSON_PARSER ("[!");
735
736 gvm_json_pull_parser_next (&parser, &event);
737 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
738 gvm_json_pull_parser_next (&parser, &event);
739 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
740 assert_that (event.error_message,
741 is_equal_to_string ("unexpected character"));
742 CLEANUP_JSON_PARSER;
743}
744
745Ensure (jsonpull, fails_for_invalid_array_other_char_after_value)
746{
747 INIT_JSON_PARSER ("[123!");
748
749 gvm_json_pull_parser_next (&parser, &event);
750 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
751 gvm_json_pull_parser_next (&parser, &event);
752 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
753 gvm_json_pull_parser_next (&parser, &event);
754 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
755 assert_that (event.error_message,
756 is_equal_to_string ("expected comma or end of container"));
757 CLEANUP_JSON_PARSER;
758}
759
760Ensure (jsonpull, fails_for_object_key_eof)
761{
762 INIT_JSON_PARSER ("{");
763
764 gvm_json_pull_parser_next (&parser, &event);
765 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
766 gvm_json_pull_parser_next (&parser, &event);
767 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
768 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
769 CLEANUP_JSON_PARSER;
770}
771
772Ensure (jsonpull, fails_for_object_key_read_error)
773{
774 INIT_READ_ERROR_JSON_PARSER ("{ ");
775
776 gvm_json_pull_parser_next (&parser, &event);
777 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
778 gvm_json_pull_parser_next (&parser, &event);
779 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
780 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
781 CLEANUP_JSON_PARSER;
782}
783
784Ensure (jsonpull, fails_for_object_key_invalid_string)
785{
786 INIT_JSON_PARSER ("{\"invalid escape:\\x\": 123}");
787
788 gvm_json_pull_parser_next (&parser, &event);
789 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
790 gvm_json_pull_parser_next (&parser, &event);
791 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
792 assert_that (event.error_message,
793 is_equal_to_string ("error parsing string"));
794 CLEANUP_JSON_PARSER;
795}
796
797Ensure (jsonpull, fails_for_invalid_object_key_bracket)
798{
799 INIT_JSON_PARSER ("{]");
800
801 gvm_json_pull_parser_next (&parser, &event);
802 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
803 gvm_json_pull_parser_next (&parser, &event);
804 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
805 assert_that (event.error_message,
806 is_equal_to_string ("unexpected closing square bracket"));
807 CLEANUP_JSON_PARSER;
808}
809
810Ensure (jsonpull, fails_for_invalid_object_key_other_char)
811{
812 INIT_JSON_PARSER ("{!");
813
814 gvm_json_pull_parser_next (&parser, &event);
815 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
816 gvm_json_pull_parser_next (&parser, &event);
817 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
818 assert_that (event.error_message,
819 is_equal_to_string ("unexpected character"));
820 CLEANUP_JSON_PARSER;
821}
822
823Ensure (jsonpull, fails_for_object_colon_eof)
824{
825 INIT_JSON_PARSER ("{\"A\" ");
826
827 gvm_json_pull_parser_next (&parser, &event);
828 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
829 gvm_json_pull_parser_next (&parser, &event);
830 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
831 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
832 CLEANUP_JSON_PARSER;
833}
834
835Ensure (jsonpull, fails_for_object_colon_read_error)
836{
837 INIT_READ_ERROR_JSON_PARSER ("{\"A\" ");
838
839 gvm_json_pull_parser_next (&parser, &event);
840 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
841 gvm_json_pull_parser_next (&parser, &event);
842 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
843 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
844 CLEANUP_JSON_PARSER;
845}
846
847Ensure (jsonpull, fails_for_object_colon_other_char)
848{
849 INIT_JSON_PARSER ("{\"A\"!");
850
851 gvm_json_pull_parser_next (&parser, &event);
852 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
853 gvm_json_pull_parser_next (&parser, &event);
854 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
855 assert_that (event.error_message, is_equal_to_string ("expected colon"));
856 CLEANUP_JSON_PARSER;
857}
858
859Ensure (jsonpull, fails_for_object_value_eof)
860{
861 INIT_JSON_PARSER ("{\"A\": ");
862
863 gvm_json_pull_parser_next (&parser, &event);
864 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
865 gvm_json_pull_parser_next (&parser, &event);
866 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
867 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
868 CLEANUP_JSON_PARSER;
869}
870
871Ensure (jsonpull, fails_for_object_value_read_error)
872{
873 INIT_READ_ERROR_JSON_PARSER ("{\"A\": ");
874
875 gvm_json_pull_parser_next (&parser, &event);
876 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
877 gvm_json_pull_parser_next (&parser, &event);
878 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
879 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
880 CLEANUP_JSON_PARSER;
881}
882
883Ensure (jsonpull, fails_for_object_value_curly_brace)
884{
885 INIT_JSON_PARSER ("{\"A\": }");
886
887 gvm_json_pull_parser_next (&parser, &event);
888 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
889 gvm_json_pull_parser_next (&parser, &event);
890 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
891 assert_that (event.error_message,
892 is_equal_to_string ("unexpected closing curly brace"));
893 CLEANUP_JSON_PARSER;
894}
895
896Ensure (jsonpull, fails_for_object_value_square_bracket)
897{
898 INIT_JSON_PARSER ("{\"A\": ]");
899
900 gvm_json_pull_parser_next (&parser, &event);
901 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
902 gvm_json_pull_parser_next (&parser, &event);
903 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
904 assert_that (event.error_message,
905 is_equal_to_string ("unexpected closing square bracket"));
906 CLEANUP_JSON_PARSER;
907}
908
909Ensure (jsonpull, fails_for_object_eof_after_value)
910{
911 INIT_JSON_PARSER ("{\"A\": 123");
912
913 gvm_json_pull_parser_next (&parser, &event);
914 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
915 gvm_json_pull_parser_next (&parser, &event);
916 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
917 gvm_json_pull_parser_next (&parser, &event);
918 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
919 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
920 CLEANUP_JSON_PARSER;
921}
922
923Ensure (jsonpull, fails_for_object_square_bracket_after_value)
924{
925 INIT_JSON_PARSER ("{\"A\": 123 ]");
926
927 gvm_json_pull_parser_next (&parser, &event);
928 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
929 gvm_json_pull_parser_next (&parser, &event);
930 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
931 gvm_json_pull_parser_next (&parser, &event);
932 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
933 assert_that (event.error_message,
934 is_equal_to_string ("unexpected closing square bracket"));
935 CLEANUP_JSON_PARSER;
936}
937
938Ensure (jsonpull, fails_for_object_eof_after_comma)
939{
940 INIT_JSON_PARSER ("{\"A\": 123, ");
941
942 gvm_json_pull_parser_next (&parser, &event);
943 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
944 gvm_json_pull_parser_next (&parser, &event);
945 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
946 gvm_json_pull_parser_next (&parser, &event);
947 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
948 assert_that (event.error_message, is_equal_to_string ("unexpected EOF"));
949 CLEANUP_JSON_PARSER;
950}
951
952Ensure (jsonpull, fails_for_read_error_after_doc_end)
953{
954 INIT_READ_ERROR_JSON_PARSER ("123 ");
955
956 gvm_json_pull_parser_next (&parser, &event);
957 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
958 gvm_json_pull_parser_next (&parser, &event);
959 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
960 assert_that (event.error_message, is_equal_to_string (JSON_READ_ERROR));
961 CLEANUP_JSON_PARSER;
962}
963
964Ensure (jsonpull, fails_for_content_after_doc_end)
965{
966 INIT_JSON_PARSER ("123 456");
967
968 gvm_json_pull_parser_next (&parser, &event);
969 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
970 gvm_json_pull_parser_next (&parser, &event);
971 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ERROR));
972 assert_that (event.error_message,
973 is_equal_to_string ("unexpected character at end of file (52)"));
974 CLEANUP_JSON_PARSER;
975}
976
977Ensure (jsonpull, fails_for_expand_before_container)
978{
979 cJSON *cjson_value;
980 gchar *error_message;
981 INIT_JSON_PARSER ("[]");
982
983 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
984 assert_that (cjson_value, is_null);
985 assert_that (error_message, is_equal_to_string ("can only expand after"
986 " array or object start"));
987
988 g_free (error_message);
989 CLEANUP_JSON_PARSER;
990}
991
992Ensure (jsonpull, fails_for_expand_after_value)
993{
994 cJSON *cjson_value;
995 gchar *error_message;
996 INIT_JSON_PARSER ("[123, 456]");
997
998 gvm_json_pull_parser_next (&parser, &event);
999 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
1000 gvm_json_pull_parser_next (&parser, &event);
1001 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_NUMBER));
1002
1003 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
1004 assert_that (cjson_value, is_null);
1005 assert_that (error_message, is_equal_to_string ("can only expand after"
1006 " array or object start"));
1007
1008 g_free (error_message);
1009 CLEANUP_JSON_PARSER;
1010}
1011
1012Ensure (jsonpull, fails_for_expand_invalid_content)
1013{
1014 cJSON *cjson_value;
1015 gchar *error_message;
1016 INIT_JSON_PARSER ("[invalid content]");
1017
1018 gvm_json_pull_parser_next (&parser, &event);
1019 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
1020
1021 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
1022 assert_that (cjson_value, is_null);
1023 assert_that (error_message,
1024 is_equal_to_string ("could not parse expanded container"));
1025
1026 g_free (error_message);
1027 CLEANUP_JSON_PARSER;
1028}
1029
1030Ensure (jsonpull, fails_for_expand_overlong)
1031{
1032 cJSON *cjson_value;
1033 gchar *error_message;
1034 INIT_JSON_PARSER ("[1234567890.123456780]");
1035 parser.parse_buffer_limit = 10;
1036
1037 gvm_json_pull_parser_next (&parser, &event);
1038 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
1039
1040 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
1041 assert_that (cjson_value, is_null);
1042 assert_that (error_message,
1043 is_equal_to_string ("container exceeds size limit of 10 bytes"));
1044
1045 g_free (error_message);
1046 CLEANUP_JSON_PARSER;
1047}
1048
1049Ensure (jsonpull, fails_for_expand_unexpected_curly_brace)
1050{
1051 cJSON *cjson_value;
1052 gchar *error_message;
1053 INIT_JSON_PARSER ("[ 123 }");
1054
1055 gvm_json_pull_parser_next (&parser, &event);
1056 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
1057
1058 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
1059 assert_that (cjson_value, is_null);
1060 assert_that (error_message,
1061 is_equal_to_string ("unexpected closing curly brace"));
1062
1063 g_free (error_message);
1064 CLEANUP_JSON_PARSER;
1065}
1066
1067Ensure (jsonpull, fails_for_expand_unexpected_square_bracket)
1068{
1069 cJSON *cjson_value;
1070 gchar *error_message;
1071 INIT_JSON_PARSER ("{ \"A\": 123 ]");
1072
1073 gvm_json_pull_parser_next (&parser, &event);
1074 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_OBJECT_START));
1075
1076 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
1077 assert_that (cjson_value, is_null);
1078 assert_that (error_message,
1079 is_equal_to_string ("unexpected closing square bracket"));
1080
1081 g_free (error_message);
1082 CLEANUP_JSON_PARSER;
1083}
1084
1085Ensure (jsonpull, fails_for_expand_eof)
1086{
1087 cJSON *cjson_value;
1088 gchar *error_message;
1089 INIT_JSON_PARSER ("[ 123");
1090
1091 gvm_json_pull_parser_next (&parser, &event);
1092 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
1093
1094 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
1095 assert_that (cjson_value, is_null);
1096 assert_that (error_message, is_equal_to_string ("unexpected EOF"));
1097
1098 g_free (error_message);
1099 CLEANUP_JSON_PARSER;
1100}
1101
1102Ensure (jsonpull, fails_for_expand_read_error)
1103{
1104 cJSON *cjson_value;
1105 gchar *error_message;
1106 INIT_READ_ERROR_JSON_PARSER ("[ 123 ");
1107
1108 gvm_json_pull_parser_next (&parser, &event);
1109 assert_that (event.type, is_equal_to (GVM_JSON_PULL_EVENT_ARRAY_START));
1110
1111 cjson_value = gvm_json_pull_expand_container (&parser, &error_message);
1112 assert_that (cjson_value, is_null);
1113 assert_that (error_message, is_equal_to_string (JSON_READ_ERROR));
1114
1115 g_free (error_message);
1116 CLEANUP_JSON_PARSER;
1117}
1118
1119int
1120main (int argc, char **argv)
1121{
1122 int ret;
1123 TestSuite *suite;
1124
1125 suite = create_test_suite ();
1126
1127 add_test_with_context (suite, jsonpull, can_init_parser_with_defaults);
1128
1129 add_test_with_context (suite, jsonpull, can_parse_false);
1130 add_test_with_context (suite, jsonpull, can_parse_true);
1131 add_test_with_context (suite, jsonpull, can_parse_null);
1132
1133 add_test_with_context (suite, jsonpull, can_parse_empty_strings);
1134 add_test_with_context (suite, jsonpull, can_parse_strings_with_content);
1135
1136 add_test_with_context (suite, jsonpull, can_parse_integer_numbers);
1137 add_test_with_context (suite, jsonpull, can_parse_floating_point_numbers);
1138
1139 add_test_with_context (suite, jsonpull, can_parse_empty_arrays);
1140 add_test_with_context (suite, jsonpull, can_parse_single_elem_arrays);
1141 add_test_with_context (suite, jsonpull, can_parse_multiple_elem_arrays);
1142
1143 add_test_with_context (suite, jsonpull, can_parse_empty_objects);
1144 add_test_with_context (suite, jsonpull, can_parse_single_elem_objects);
1145 add_test_with_context (suite, jsonpull, can_parse_multiple_elem_objects);
1146 add_test_with_context (suite, jsonpull, can_parse_nested_containers);
1147 add_test_with_context (suite, jsonpull, can_expand_arrays);
1148 add_test_with_context (suite, jsonpull, can_expand_objects);
1149
1150 add_test_with_context (suite, jsonpull, fails_for_read_error);
1151
1152 add_test_with_context (suite, jsonpull, fails_for_misspelled_true);
1153 add_test_with_context (suite, jsonpull, fails_for_incomplete_true);
1154 add_test_with_context (suite, jsonpull, fails_for_misspelled_false);
1155 add_test_with_context (suite, jsonpull, fails_for_misspelled_null);
1156
1157 add_test_with_context (suite, jsonpull, fails_for_string_eof);
1158 add_test_with_context (suite, jsonpull, fails_for_string_read_error);
1159 add_test_with_context (suite, jsonpull, fails_for_overlong_string);
1160 add_test_with_context (suite, jsonpull, fails_for_invalid_string);
1161
1162 add_test_with_context (suite, jsonpull, fails_for_number_read_error);
1163 add_test_with_context (suite, jsonpull, fails_for_overlong_number);
1164 add_test_with_context (suite, jsonpull, fails_for_invalid_number);
1165
1166 add_test_with_context (suite, jsonpull, fails_for_array_eof);
1167 add_test_with_context (suite, jsonpull, fails_for_array_eof_after_value);
1168 add_test_with_context (suite, jsonpull, fails_for_array_eof_after_comma);
1169 add_test_with_context (suite, jsonpull, fails_for_array_read_error);
1170 add_test_with_context (suite, jsonpull, fails_for_invalid_array_bracket);
1171 add_test_with_context (suite, jsonpull,
1172 fails_for_invalid_array_bracket_after_value);
1173 add_test_with_context (suite, jsonpull, fails_for_invalid_array_other_char);
1174 add_test_with_context (suite, jsonpull,
1175 fails_for_invalid_array_other_char_after_value);
1176
1177 add_test_with_context (suite, jsonpull, fails_for_object_key_eof);
1178 add_test_with_context (suite, jsonpull, fails_for_object_key_read_error);
1179 add_test_with_context (suite, jsonpull, fails_for_object_key_invalid_string);
1180 add_test_with_context (suite, jsonpull, fails_for_invalid_object_key_bracket);
1181 add_test_with_context (suite, jsonpull,
1182 fails_for_invalid_object_key_other_char);
1183
1184 add_test_with_context (suite, jsonpull, fails_for_object_colon_eof);
1185 add_test_with_context (suite, jsonpull, fails_for_object_colon_read_error);
1186 add_test_with_context (suite, jsonpull, fails_for_object_colon_other_char);
1187
1188 add_test_with_context (suite, jsonpull, fails_for_object_value_eof);
1189 add_test_with_context (suite, jsonpull, fails_for_object_value_read_error);
1190 add_test_with_context (suite, jsonpull, fails_for_object_value_curly_brace);
1191 add_test_with_context (suite, jsonpull,
1192 fails_for_object_value_square_bracket);
1193 add_test_with_context (suite, jsonpull, fails_for_object_eof_after_value);
1194 add_test_with_context (suite, jsonpull, fails_for_object_eof_after_comma);
1195 add_test_with_context (suite, jsonpull,
1196 fails_for_object_square_bracket_after_value);
1197
1198 add_test_with_context (suite, jsonpull, fails_for_read_error_after_doc_end);
1199 add_test_with_context (suite, jsonpull, fails_for_content_after_doc_end);
1200
1201 add_test_with_context (suite, jsonpull, fails_for_expand_before_container);
1202 add_test_with_context (suite, jsonpull, fails_for_expand_after_value);
1203 add_test_with_context (suite, jsonpull, fails_for_expand_invalid_content);
1204 add_test_with_context (suite, jsonpull, fails_for_expand_overlong);
1205 add_test_with_context (suite, jsonpull,
1206 fails_for_expand_unexpected_curly_brace);
1207 add_test_with_context (suite, jsonpull,
1208 fails_for_expand_unexpected_square_bracket);
1209 add_test_with_context (suite, jsonpull, fails_for_expand_read_error);
1210 add_test_with_context (suite, jsonpull, fails_for_expand_eof);
1211
1212 if (argc > 1)
1213 ret = run_single_test (suite, argv[1], create_text_reporter ());
1214 else
1215 ret = run_test_suite (suite, create_text_reporter ());
1216
1217 destroy_test_suite (suite);
1218
1219 return ret;
1220}
gvm_json_pull_parser_cleanup
void gvm_json_pull_parser_cleanup(gvm_json_pull_parser_t *parser)
Frees the data of a JSON pull parser.
Definition jsonpull.c:120
gvm_json_pull_event_cleanup
void gvm_json_pull_event_cleanup(gvm_json_pull_event_t *event)
Frees all data of JSON pull event data structure.
Definition jsonpull.c:61
gvm_json_pull_parser_next
void gvm_json_pull_parser_next(gvm_json_pull_parser_t *parser, gvm_json_pull_event_t *event)
Get the next event from a JSON pull parser.
Definition jsonpull.c:669
gvm_json_pull_parser_init
void gvm_json_pull_parser_init(gvm_json_pull_parser_t *parser, FILE *input_stream)
Initializes a JSON pull parser with default buffer sizes.
Definition jsonpull.c:109
gvm_json_pull_expand_container
cJSON * gvm_json_pull_expand_container(gvm_json_pull_parser_t *parser, gchar **error_message)
Expands the current array or object of a JSON pull parser.
Definition jsonpull.c:746
GVM_JSON_PULL_READ_BUFFER_SIZE
#define GVM_JSON_PULL_READ_BUFFER_SIZE
Definition jsonpull.h:80
GVM_JSON_PULL_PARSE_BUFFER_LIMIT
#define GVM_JSON_PULL_PARSE_BUFFER_LIMIT
Definition jsonpull.h:78
GVM_JSON_PULL_EVENT_STRING
@ GVM_JSON_PULL_EVENT_STRING
Definition jsonpull.h:47
GVM_JSON_PULL_EVENT_OBJECT_START
@ GVM_JSON_PULL_EVENT_OBJECT_START
Definition jsonpull.h:45
GVM_JSON_PULL_EVENT_ERROR
@ GVM_JSON_PULL_EVENT_ERROR
Definition jsonpull.h:52
GVM_JSON_PULL_EVENT_NULL
@ GVM_JSON_PULL_EVENT_NULL
Definition jsonpull.h:50
GVM_JSON_PULL_EVENT_EOF
@ GVM_JSON_PULL_EVENT_EOF
Definition jsonpull.h:51
GVM_JSON_PULL_EVENT_NUMBER
@ GVM_JSON_PULL_EVENT_NUMBER
Definition jsonpull.h:48
GVM_JSON_PULL_EVENT_ARRAY_END
@ GVM_JSON_PULL_EVENT_ARRAY_END
Definition jsonpull.h:44
GVM_JSON_PULL_EVENT_OBJECT_END
@ GVM_JSON_PULL_EVENT_OBJECT_END
Definition jsonpull.h:46
GVM_JSON_PULL_EVENT_ARRAY_START
@ GVM_JSON_PULL_EVENT_ARRAY_START
Definition jsonpull.h:43
GVM_JSON_PULL_EVENT_BOOLEAN
@ GVM_JSON_PULL_EVENT_BOOLEAN
Definition jsonpull.h:49
INIT_JSON_PARSER
#define INIT_JSON_PARSER(json_string)
Definition jsonpull_tests.c:44
BeforeEach
BeforeEach(jsonpull)
Definition jsonpull_tests.c:14
Ensure
Ensure(jsonpull, can_init_parser_with_defaults)
Definition jsonpull_tests.c:76
main
int main(int argc, char **argv)
Definition jsonpull_tests.c:1120
fstropen_r
static FILE * fstropen_r(const char *str)
Definition jsonpull_tests.c:25
read_with_error_on_eof
static ssize_t read_with_error_on_eof(void *stream_cookie, char *buf, size_t size)
Definition jsonpull_tests.c:31
JSON_READ_ERROR
#define JSON_READ_ERROR
Definition jsonpull_tests.c:74
INIT_READ_ERROR_JSON_PARSER
#define INIT_READ_ERROR_JSON_PARSER(json_string)
Definition jsonpull_tests.c:52
CLEANUP_JSON_PARSER
#define CLEANUP_JSON_PARSER
Definition jsonpull_tests.c:64
AfterEach
AfterEach(jsonpull)
Definition jsonpull_tests.c:17
CHECK_PATH_EQUALS
#define CHECK_PATH_EQUALS(expected_path_str)
Definition jsonpull_tests.c:69
Describe
Describe(jsonpull)
gvm_json_pull_parser_t
A json pull parser.
Definition jsonpull.h:86
gvm_json_pull_parser_t::read_buffer_size
size_t read_buffer_size
Size of the stream reading buffer.
Definition jsonpull.h:93
gvm_json_pull_parser_t::parse_buffer_limit
size_t parse_buffer_limit
Maximum parse buffer size.
Definition jsonpull.h:98
gvm_json_pull_parser_t::input_stream
FILE * input_stream
Input stream.
Definition jsonpull.h:91