diff options
Diffstat (limited to 'fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c')
| -rw-r--r-- | fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c | 547 |
1 files changed, 547 insertions, 0 deletions
diff --git a/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c b/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c new file mode 100644 index 000000000..865f60b68 --- /dev/null +++ b/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c @@ -0,0 +1,547 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * Copyright (c) 2010-2012 Graeme Smecher <graeme.smecher@mail.mcgill.ca> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#ifdef HAVE_CONFIG_H +#include <jansson_private_config.h> +#endif + +#include <jansson_config.h> + +#include "util.h" +#include <jansson.h> +#include <math.h> +#include <stdio.h> +#include <string.h> + +#ifdef INFINITY +// This test triggers "warning C4756: overflow in constant arithmetic" +// in Visual Studio. This warning is triggered here by design, so disable it. +// (This can only be done on function level so we keep these tests separate) +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4756) +#endif +static void test_inifity() { + json_error_t error; + + if (json_pack_ex(&error, 0, "f", INFINITY)) + fail("json_pack infinity incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, + 1, 1); + + if (json_pack_ex(&error, 0, "[f]", INFINITY)) + fail("json_pack infinity array element incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, + 2, 2); + + if (json_pack_ex(&error, 0, "{s:f}", "key", INFINITY)) + fail("json_pack infinity object value incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, + 4, 4); + +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} +#endif // INFINITY + +static void run_tests() { + json_t *value; + int i; + char buffer[4] = {'t', 'e', 's', 't'}; + json_error_t error; + + /* + * Simple, valid json_pack cases + */ + /* true */ + value = json_pack("b", 1); + if (!json_is_true(value)) + fail("json_pack boolean failed"); + if (value->refcount != (size_t)-1) + fail("json_pack boolean refcount failed"); + json_decref(value); + + /* false */ + value = json_pack("b", 0); + if (!json_is_false(value)) + fail("json_pack boolean failed"); + if (value->refcount != (size_t)-1) + fail("json_pack boolean refcount failed"); + json_decref(value); + + /* null */ + value = json_pack("n"); + if (!json_is_null(value)) + fail("json_pack null failed"); + if (value->refcount != (size_t)-1) + fail("json_pack null refcount failed"); + json_decref(value); + + /* integer */ + value = json_pack("i", 1); + if (!json_is_integer(value) || json_integer_value(value) != 1) + fail("json_pack integer failed"); + if (value->refcount != (size_t)1) + fail("json_pack integer refcount failed"); + json_decref(value); + + /* integer from json_int_t */ + value = json_pack("I", (json_int_t)555555); + if (!json_is_integer(value) || json_integer_value(value) != 555555) + fail("json_pack json_int_t failed"); + if (value->refcount != (size_t)1) + fail("json_pack integer refcount failed"); + json_decref(value); + + /* real */ + value = json_pack("f", 1.0); + if (!json_is_real(value) || json_real_value(value) != 1.0) + fail("json_pack real failed"); + if (value->refcount != (size_t)1) + fail("json_pack real refcount failed"); + json_decref(value); + + /* string */ + value = json_pack("s", "test"); + if (!json_is_string(value) || strcmp("test", json_string_value(value))) + fail("json_pack string failed"); + if (value->refcount != (size_t)1) + fail("json_pack string refcount failed"); + json_decref(value); + + /* nullable string (defined case) */ + value = json_pack("s?", "test"); + if (!json_is_string(value) || strcmp("test", json_string_value(value))) + fail("json_pack nullable string (defined case) failed"); + if (value->refcount != (size_t)1) + fail("json_pack nullable string (defined case) refcount failed"); + json_decref(value); + + /* nullable string (NULL case) */ + value = json_pack("s?", NULL); + if (!json_is_null(value)) + fail("json_pack nullable string (NULL case) failed"); + if (value->refcount != (size_t)-1) + fail("json_pack nullable string (NULL case) refcount failed"); + json_decref(value); + + /* nullable string concatenation */ + if (json_pack_ex(&error, 0, "s?+", "test", "ing")) + fail("json_pack failed to catch invalid format 's?+'"); + check_error(json_error_invalid_format, "Cannot use '+' on optional strings", + "<format>", 1, 2, 2); + + /* nullable string with integer length */ + if (json_pack_ex(&error, 0, "s?#", "test", 4)) + fail("json_pack failed to catch invalid format 's?#'"); + check_error(json_error_invalid_format, "Cannot use '#' on optional strings", + "<format>", 1, 2, 2); + + /* string and length (int) */ + value = json_pack("s#", "test asdf", 4); + if (!json_is_string(value) || strcmp("test", json_string_value(value))) + fail("json_pack string and length failed"); + if (value->refcount != (size_t)1) + fail("json_pack string and length refcount failed"); + json_decref(value); + + /* string and length (size_t) */ + value = json_pack("s%", "test asdf", (size_t)4); + if (!json_is_string(value) || strcmp("test", json_string_value(value))) + fail("json_pack string and length failed"); + if (value->refcount != (size_t)1) + fail("json_pack string and length refcount failed"); + json_decref(value); + + /* string and length (int), non-NUL terminated string */ + value = json_pack("s#", buffer, 4); + if (!json_is_string(value) || strcmp("test", json_string_value(value))) + fail("json_pack string and length (int) failed"); + if (value->refcount != (size_t)1) + fail("json_pack string and length (int) refcount failed"); + json_decref(value); + + /* string and length (size_t), non-NUL terminated string */ + value = json_pack("s%", buffer, (size_t)4); + if (!json_is_string(value) || strcmp("test", json_string_value(value))) + fail("json_pack string and length (size_t) failed"); + if (value->refcount != (size_t)1) + fail("json_pack string and length (size_t) refcount failed"); + json_decref(value); + + /* string concatenation */ + if (json_pack("s+", "test", NULL)) + fail("json_pack string concatenation succeeded with NULL string"); + + value = json_pack("s++", "te", "st", "ing"); + if (!json_is_string(value) || strcmp("testing", json_string_value(value))) + fail("json_pack string concatenation failed"); + if (value->refcount != (size_t)1) + fail("json_pack string concatenation refcount failed"); + json_decref(value); + + /* string concatenation and length (int) */ + value = json_pack("s#+#+", "test", 1, "test", 2, "test"); + if (!json_is_string(value) || strcmp("ttetest", json_string_value(value))) + fail("json_pack string concatenation and length (int) failed"); + if (value->refcount != (size_t)1) + fail("json_pack string concatenation and length (int) refcount failed"); + json_decref(value); + + /* string concatenation and length (size_t) */ + value = json_pack("s%+%+", "test", (size_t)1, "test", (size_t)2, "test"); + if (!json_is_string(value) || strcmp("ttetest", json_string_value(value))) + fail("json_pack string concatenation and length (size_t) failed"); + if (value->refcount != (size_t)1) + fail("json_pack string concatenation and length (size_t) refcount " + "failed"); + json_decref(value); + + /* empty object */ + value = json_pack("{}", 1.0); + if (!json_is_object(value) || json_object_size(value) != 0) + fail("json_pack empty object failed"); + if (value->refcount != (size_t)1) + fail("json_pack empty object refcount failed"); + json_decref(value); + + /* empty list */ + value = json_pack("[]", 1.0); + if (!json_is_array(value) || json_array_size(value) != 0) + fail("json_pack empty list failed"); + if (value->refcount != (size_t)1) + fail("json_pack empty list failed"); + json_decref(value); + + /* non-incref'd object */ + value = json_pack("o", json_integer(1)); + if (!json_is_integer(value) || json_integer_value(value) != 1) + fail("json_pack object failed"); + if (value->refcount != (size_t)1) + fail("json_pack integer refcount failed"); + json_decref(value); + + /* non-incref'd nullable object (defined case) */ + value = json_pack("o?", json_integer(1)); + if (!json_is_integer(value) || json_integer_value(value) != 1) + fail("json_pack nullable object (defined case) failed"); + if (value->refcount != (size_t)1) + fail("json_pack nullable object (defined case) refcount failed"); + json_decref(value); + + /* non-incref'd nullable object (NULL case) */ + value = json_pack("o?", NULL); + if (!json_is_null(value)) + fail("json_pack nullable object (NULL case) failed"); + if (value->refcount != (size_t)-1) + fail("json_pack nullable object (NULL case) refcount failed"); + json_decref(value); + + /* incref'd object */ + value = json_pack("O", json_integer(1)); + if (!json_is_integer(value) || json_integer_value(value) != 1) + fail("json_pack object failed"); + if (value->refcount != (size_t)2) + fail("json_pack integer refcount failed"); + json_decref(value); + json_decref(value); + + /* incref'd nullable object (defined case) */ + value = json_pack("O?", json_integer(1)); + if (!json_is_integer(value) || json_integer_value(value) != 1) + fail("json_pack incref'd nullable object (defined case) failed"); + if (value->refcount != (size_t)2) + fail("json_pack incref'd nullable object (defined case) refcount " + "failed"); + json_decref(value); + json_decref(value); + + /* incref'd nullable object (NULL case) */ + value = json_pack("O?", NULL); + if (!json_is_null(value)) + fail("json_pack incref'd nullable object (NULL case) failed"); + if (value->refcount != (size_t)-1) + fail("json_pack incref'd nullable object (NULL case) refcount failed"); + + /* simple object */ + value = json_pack("{s:[]}", "foo"); + if (!json_is_object(value) || json_object_size(value) != 1) + fail("json_pack array failed"); + if (!json_is_array(json_object_get(value, "foo"))) + fail("json_pack array failed"); + if (json_object_get(value, "foo")->refcount != (size_t)1) + fail("json_pack object refcount failed"); + json_decref(value); + + /* object with complex key */ + value = json_pack("{s+#+: []}", "foo", "barbar", 3, "baz"); + if (!json_is_object(value) || json_object_size(value) != 1) + fail("json_pack array failed"); + if (!json_is_array(json_object_get(value, "foobarbaz"))) + fail("json_pack array failed"); + if (json_object_get(value, "foobarbaz")->refcount != (size_t)1) + fail("json_pack object refcount failed"); + json_decref(value); + + /* object with optional members */ + value = json_pack("{s:s,s:o,s:O}", "a", NULL, "b", NULL, "c", NULL); + if (value) + fail("json_pack object optional incorrectly succeeded"); + + value = json_pack("{s:**}", "a", NULL); + if (value) + fail("json_pack object optional invalid incorrectly succeeded"); + + if (json_pack_ex(&error, 0, "{s:i*}", "a", 1)) + fail("json_pack object optional invalid incorrectly succeeded"); + check_error(json_error_invalid_format, "Expected format 's', got '*'", "<format>", 1, + 5, 5); + + value = json_pack("{s:s*,s:o*,s:O*}", "a", NULL, "b", NULL, "c", NULL); + if (!json_is_object(value) || json_object_size(value) != 0) + fail("json_pack object optional failed"); + json_decref(value); + + value = json_pack("{s:s*}", "key", "\xff\xff"); + if (value) + fail("json_pack object optional with invalid UTF-8 incorrectly " + "succeeded"); + + if (json_pack_ex(&error, 0, "{s: s*#}", "key", "test", 1)) + fail("json_pack failed to catch invalid format 's*#'"); + check_error(json_error_invalid_format, "Cannot use '#' on optional strings", + "<format>", 1, 6, 6); + + if (json_pack_ex(&error, 0, "{s: s*+}", "key", "test", "ing")) + fail("json_pack failed to catch invalid format 's*+'"); + check_error(json_error_invalid_format, "Cannot use '+' on optional strings", + "<format>", 1, 6, 6); + + /* simple array */ + value = json_pack("[i,i,i]", 0, 1, 2); + if (!json_is_array(value) || json_array_size(value) != 3) + fail("json_pack object failed"); + for (i = 0; i < 3; i++) { + if (!json_is_integer(json_array_get(value, i)) || + json_integer_value(json_array_get(value, i)) != i) + + fail("json_pack integer array failed"); + } + json_decref(value); + + /* simple array with optional members */ + value = json_pack("[s,o,O]", NULL, NULL, NULL); + if (value) + fail("json_pack array optional incorrectly succeeded"); + + if (json_pack_ex(&error, 0, "[i*]", 1)) + fail("json_pack array optional invalid incorrectly succeeded"); + check_error(json_error_invalid_format, "Unexpected format character '*'", "<format>", + 1, 3, 3); + + value = json_pack("[**]", NULL); + if (value) + fail("json_pack array optional invalid incorrectly succeeded"); + value = json_pack("[s*,o*,O*]", NULL, NULL, NULL); + if (!json_is_array(value) || json_array_size(value) != 0) + fail("json_pack array optional failed"); + json_decref(value); + +#ifdef NAN + /* Invalid float values */ + if (json_pack_ex(&error, 0, "f", NAN)) + fail("json_pack NAN incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, + 1, 1); + + if (json_pack_ex(&error, 0, "[f]", NAN)) + fail("json_pack NAN array element incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, + 2, 2); + + if (json_pack_ex(&error, 0, "{s:f}", "key", NAN)) + fail("json_pack NAN object value incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, + 4, 4); +#endif + +#ifdef INFINITY + test_inifity(); +#endif + + /* Whitespace; regular string */ + value = json_pack(" s\t ", "test"); + if (!json_is_string(value) || strcmp("test", json_string_value(value))) + fail("json_pack string (with whitespace) failed"); + json_decref(value); + + /* Whitespace; empty array */ + value = json_pack("[ ]"); + if (!json_is_array(value) || json_array_size(value) != 0) + fail("json_pack empty array (with whitespace) failed"); + json_decref(value); + + /* Whitespace; array */ + value = json_pack("[ i , i, i ] ", 1, 2, 3); + if (!json_is_array(value) || json_array_size(value) != 3) + fail("json_pack array (with whitespace) failed"); + json_decref(value); + + /* + * Invalid cases + */ + + /* newline in format string */ + if (json_pack_ex(&error, 0, "{\n\n1")) + fail("json_pack failed to catch invalid format '1'"); + check_error(json_error_invalid_format, "Expected format 's', got '1'", "<format>", 3, + 1, 4); + + /* mismatched open/close array/object */ + if (json_pack_ex(&error, 0, "[}")) + fail("json_pack failed to catch mismatched '}'"); + check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", + 1, 2, 2); + + if (json_pack_ex(&error, 0, "{]")) + fail("json_pack failed to catch mismatched ']'"); + check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, + 2, 2); + + /* missing close array */ + if (json_pack_ex(&error, 0, "[")) + fail("json_pack failed to catch missing ']'"); + check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", + 1, 2, 2); + + /* missing close object */ + if (json_pack_ex(&error, 0, "{")) + fail("json_pack failed to catch missing '}'"); + check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", + 1, 2, 2); + + /* garbage after format string */ + if (json_pack_ex(&error, 0, "[i]a", 42)) + fail("json_pack failed to catch garbage after format string"); + check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, + 4, 4); + + if (json_pack_ex(&error, 0, "ia", 42)) + fail("json_pack failed to catch garbage after format string"); + check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, + 2, 2); + + /* NULL string */ + if (json_pack_ex(&error, 0, "s", NULL)) + fail("json_pack failed to catch null argument string"); + check_error(json_error_null_value, "NULL string", "<args>", 1, 1, 1); + + /* + on its own */ + if (json_pack_ex(&error, 0, "+", NULL)) + fail("json_pack failed to a lone +"); + check_error(json_error_invalid_format, "Unexpected format character '+'", "<format>", + 1, 1, 1); + + /* Empty format */ + if (json_pack_ex(&error, 0, "")) + fail("json_pack failed to catch empty format string"); + check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", + -1, -1, 0); + + /* NULL format */ + if (json_pack_ex(&error, 0, NULL)) + fail("json_pack failed to catch NULL format string"); + check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", + -1, -1, 0); + + /* NULL key */ + if (json_pack_ex(&error, 0, "{s:i}", NULL, 1)) + fail("json_pack failed to catch NULL key"); + check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2); + + /* NULL value followed by object still steals the object's ref */ + value = json_incref(json_object()); + if (json_pack_ex(&error, 0, "{s:s,s:o}", "badnull", NULL, "dontleak", value)) + fail("json_pack failed to catch NULL value"); + check_error(json_error_null_value, "NULL string", "<args>", 1, 4, 4); + if (value->refcount != (size_t)1) + fail("json_pack failed to steal reference after error."); + json_decref(value); + + /* More complicated checks for row/columns */ + if (json_pack_ex(&error, 0, "{ {}: s }", "foo")) + fail("json_pack failed to catch object as key"); + check_error(json_error_invalid_format, "Expected format 's', got '{'", "<format>", 1, + 3, 3); + + /* Complex object */ + if (json_pack_ex(&error, 0, "{ s: {}, s:[ii{} }", "foo", "bar", 12, 13)) + fail("json_pack failed to catch missing ]"); + check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", + 1, 19, 19); + + /* Complex array */ + if (json_pack_ex(&error, 0, "[[[[[ [[[[[ [[[[ }]]]] ]]]] ]]]]]")) + fail("json_pack failed to catch extra }"); + check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", + 1, 21, 21); + + /* Invalid UTF-8 in object key */ + if (json_pack_ex(&error, 0, "{s:i}", "\xff\xff", 42)) + fail("json_pack failed to catch invalid UTF-8 in an object key"); + check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 2, 2); + + /* Invalid UTF-8 in a string */ + if (json_pack_ex(&error, 0, "{s:s}", "foo", "\xff\xff")) + fail("json_pack failed to catch invalid UTF-8 in a string"); + check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 4, 4); + + /* Invalid UTF-8 in an optional '?' string */ + if (json_pack_ex(&error, 0, "{s:s?}", "foo", "\xff\xff")) + fail("json_pack failed to catch invalid UTF-8 in an optional '?' " + "string"); + check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5); + + /* Invalid UTF-8 in an optional '*' string */ + if (json_pack_ex(&error, 0, "{s:s*}", "foo", "\xff\xff")) + fail("json_pack failed to catch invalid UTF-8 in an optional '*' " + "string"); + check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5); + + /* Invalid UTF-8 in a concatenated key */ + if (json_pack_ex(&error, 0, "{s+:i}", "\xff\xff", "concat", 42)) + fail("json_pack failed to catch invalid UTF-8 in an object key"); + check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 3, 3); + + if (json_pack_ex(&error, 0, "{s:o}", "foo", NULL)) + fail("json_pack failed to catch nullable object"); + check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4); + + if (json_pack_ex(&error, 0, "{s:O}", "foo", NULL)) + fail("json_pack failed to catch nullable incref object"); + check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4); + + if (json_pack_ex(&error, 0, "{s+:o}", "foo", "bar", NULL)) + fail("json_pack failed to catch non-nullable object value"); + check_error(json_error_null_value, "NULL object", "<args>", 1, 5, 5); + + if (json_pack_ex(&error, 0, "[1s", "Hi")) + fail("json_pack failed to catch invalid format"); + check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>", + 1, 2, 2); + + if (json_pack_ex(&error, 0, "[1s+", "Hi", "ya")) + fail("json_pack failed to catch invalid format"); + check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>", + 1, 2, 2); + + if (json_pack_ex(&error, 0, "[so]", NULL, json_object())) + fail("json_pack failed to catch NULL value"); + check_error(json_error_null_value, "NULL string", "<args>", 1, 2, 2); +} |