diff options
Diffstat (limited to 'src/fluent-bit/lib/jansson-e23f558/test')
296 files changed, 6236 insertions, 0 deletions
diff --git a/src/fluent-bit/lib/jansson-e23f558/test/.gitignore b/src/fluent-bit/lib/jansson-e23f558/test/.gitignore new file mode 100644 index 000000000..6a33dea39 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/.gitignore @@ -0,0 +1,20 @@ +logs +bin/json_process +suites/api/test_array +suites/api/test_chaos +suites/api/test_copy +suites/api/test_cpp +suites/api/test_dump +suites/api/test_dump_callback +suites/api/test_equal +suites/api/test_load +suites/api/test_load_callback +suites/api/test_loadb +suites/api/test_memory_funcs +suites/api/test_number +suites/api/test_object +suites/api/test_pack +suites/api/test_simple +suites/api/test_sprintf +suites/api/test_unpack +suites/api/test_version diff --git a/src/fluent-bit/lib/jansson-e23f558/test/Makefile.am b/src/fluent-bit/lib/jansson-e23f558/test/Makefile.am new file mode 100644 index 000000000..344d18d7e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/Makefile.am @@ -0,0 +1,10 @@ +SUBDIRS = bin suites ossfuzz +EXTRA_DIST = scripts run-suites + +TESTS = run-suites +TESTS_ENVIRONMENT = \ + top_srcdir=$(top_srcdir) \ + top_builddir=$(top_builddir) + +clean-local: + rm -rf logs diff --git a/src/fluent-bit/lib/jansson-e23f558/test/bin/Makefile.am b/src/fluent-bit/lib/jansson-e23f558/test/bin/Makefile.am new file mode 100644 index 000000000..63b6dce7e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/bin/Makefile.am @@ -0,0 +1,5 @@ +check_PROGRAMS = json_process + +AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src +LDFLAGS = -static # for speed and Valgrind +LDADD = $(top_builddir)/src/libjansson.la diff --git a/src/fluent-bit/lib/jansson-e23f558/test/bin/json_process.c b/src/fluent-bit/lib/jansson-e23f558/test/bin/json_process.c new file mode 100644 index 000000000..fc98543fc --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/bin/json_process.c @@ -0,0 +1,366 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * 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 <ctype.h> +#include <jansson.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#ifdef HAVE_LOCALE_H +#include <locale.h> +#endif + +#if _WIN32 +#include <fcntl.h> /* for _O_BINARY */ +#include <io.h> /* for _setmode() */ + +static const char dir_sep = '\\'; +#else +static const char dir_sep = '/'; +#endif + +struct config { + int indent; + int compact; + int preserve_order; + int ensure_ascii; + int sort_keys; + int strip; + int use_env; + int have_hashseed; + int hashseed; + int precision; +} conf; + +#define l_isspace(c) ((c) == ' ' || (c) == '\n' || (c) == '\r' || (c) == '\t') + +/* Return a pointer to the first non-whitespace character of str. + Modifies str so that all trailing whitespace characters are + replaced by '\0'. */ +static const char *strip(char *str) { + size_t length; + char *result = str; + while (*result && l_isspace(*result)) + result++; + + length = strlen(result); + if (length == 0) + return result; + + while (l_isspace(result[length - 1])) + result[--length] = '\0'; + + return result; +} + +static char *loadfile(FILE *file) { + size_t fsize, ret; + char *buf; + + fseek(file, 0, SEEK_END); + fsize = ftell(file); + fseek(file, 0, SEEK_SET); + + buf = malloc(fsize + 1); + ret = fread(buf, 1, fsize, file); + if (ret != fsize) + exit(1); + buf[fsize] = '\0'; + + return buf; +} + +static void read_conf(FILE *conffile) { + char *buffer, *line, *val; + + buffer = loadfile(conffile); + for (line = strtok(buffer, "\r\n"); line; line = strtok(NULL, "\r\n")) { + if (!strncmp(line, "export ", 7)) + continue; + val = strchr(line, '='); + if (!val) { + printf("invalid configuration line\n"); + break; + } + *val++ = '\0'; + + if (!strcmp(line, "JSON_INDENT")) + conf.indent = atoi(val); + if (!strcmp(line, "JSON_COMPACT")) + conf.compact = atoi(val); + if (!strcmp(line, "JSON_ENSURE_ASCII")) + conf.ensure_ascii = atoi(val); + if (!strcmp(line, "JSON_PRESERVE_ORDER")) + conf.preserve_order = atoi(val); + if (!strcmp(line, "JSON_SORT_KEYS")) + conf.sort_keys = atoi(val); + if (!strcmp(line, "JSON_REAL_PRECISION")) + conf.precision = atoi(val); + if (!strcmp(line, "STRIP")) + conf.strip = atoi(val); + if (!strcmp(line, "HASHSEED")) { + conf.have_hashseed = 1; + conf.hashseed = atoi(val); + } else { + conf.have_hashseed = 0; + } + } + + free(buffer); +} + +static int cmpfile(const char *str, const char *path, const char *fname) { + char filename[1024], *buffer; + int ret; + FILE *file; + + sprintf(filename, "%s%c%s", path, dir_sep, fname); + file = fopen(filename, "rb"); + if (!file) { + if (conf.strip) + strcat(filename, ".strip"); + else + strcat(filename, ".normal"); + file = fopen(filename, "rb"); + } + if (!file) { + printf("Error: test result file could not be opened.\n"); + exit(1); + } + + buffer = loadfile(file); + if (strcmp(buffer, str) != 0) + ret = 1; + else + ret = 0; + free(buffer); + fclose(file); + + return ret; +} + +int use_conf(char *test_path) { + int ret; + size_t flags = 0; + char filename[1024], errstr[1024]; + char *buffer; + FILE *infile, *conffile; + json_t *json; + json_error_t error; + + sprintf(filename, "%s%cinput", test_path, dir_sep); + if (!(infile = fopen(filename, "rb"))) { + fprintf(stderr, "Could not open \"%s\"\n", filename); + return 2; + } + + sprintf(filename, "%s%cenv", test_path, dir_sep); + conffile = fopen(filename, "rb"); + if (conffile) { + read_conf(conffile); + fclose(conffile); + } + + if (conf.indent < 0 || conf.indent > 31) { + fprintf(stderr, "invalid value for JSON_INDENT: %d\n", conf.indent); + fclose(infile); + return 2; + } + if (conf.indent) + flags |= JSON_INDENT(conf.indent); + + if (conf.compact) + flags |= JSON_COMPACT; + + if (conf.ensure_ascii) + flags |= JSON_ENSURE_ASCII; + + if (conf.preserve_order) + flags |= JSON_PRESERVE_ORDER; + + if (conf.sort_keys) + flags |= JSON_SORT_KEYS; + + if (conf.precision < 0 || conf.precision > 31) { + fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n", conf.precision); + fclose(infile); + return 2; + } + if (conf.precision) + flags |= JSON_REAL_PRECISION(conf.precision); + + if (conf.have_hashseed) + json_object_seed(conf.hashseed); + + if (conf.strip) { + /* Load to memory, strip leading and trailing whitespace */ + buffer = loadfile(infile); + json = json_loads(strip(buffer), 0, &error); + free(buffer); + } else + json = json_loadf(infile, 0, &error); + + fclose(infile); + + if (!json) { + sprintf(errstr, "%d %d %d\n%s\n", error.line, error.column, error.position, + error.text); + + ret = cmpfile(errstr, test_path, "error"); + return ret; + } + + buffer = json_dumps(json, flags); + ret = cmpfile(buffer, test_path, "output"); + free(buffer); + json_decref(json); + + return ret; +} + +static int getenv_int(const char *name) { + char *value, *end; + long result; + + value = getenv(name); + if (!value) + return 0; + + result = strtol(value, &end, 10); + if (*end != '\0') + return 0; + + return (int)result; +} + +int use_env() { + int indent, precision; + size_t flags = 0; + json_t *json; + json_error_t error; + +#ifdef _WIN32 + /* On Windows, set stdout and stderr to binary mode to avoid + outputting DOS line terminators */ + _setmode(_fileno(stdout), _O_BINARY); + _setmode(_fileno(stderr), _O_BINARY); +#endif + + indent = getenv_int("JSON_INDENT"); + if (indent < 0 || indent > 31) { + fprintf(stderr, "invalid value for JSON_INDENT: %d\n", indent); + return 2; + } + if (indent > 0) + flags |= JSON_INDENT(indent); + + if (getenv_int("JSON_COMPACT") > 0) + flags |= JSON_COMPACT; + + if (getenv_int("JSON_ENSURE_ASCII")) + flags |= JSON_ENSURE_ASCII; + + if (getenv_int("JSON_PRESERVE_ORDER")) + flags |= JSON_PRESERVE_ORDER; + + if (getenv_int("JSON_SORT_KEYS")) + flags |= JSON_SORT_KEYS; + + precision = getenv_int("JSON_REAL_PRECISION"); + if (precision < 0 || precision > 31) { + fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n", precision); + return 2; + } + + if (getenv("HASHSEED")) + json_object_seed(getenv_int("HASHSEED")); + + if (precision > 0) + flags |= JSON_REAL_PRECISION(precision); + + if (getenv_int("STRIP")) { + /* Load to memory, strip leading and trailing whitespace */ + size_t size = 0, used = 0; + char *buffer = NULL, *buf_ck = NULL; + + while (1) { + size_t count; + + size = (size == 0 ? 128 : size * 2); + buf_ck = realloc(buffer, size); + if (!buf_ck) { + fprintf(stderr, "Unable to allocate %d bytes\n", (int)size); + free(buffer); + return 1; + } + buffer = buf_ck; + + count = fread(buffer + used, 1, size - used, stdin); + if (count < size - used) { + buffer[used + count] = '\0'; + break; + } + used += count; + } + + json = json_loads(strip(buffer), 0, &error); + free(buffer); + } else + json = json_loadf(stdin, 0, &error); + + if (!json) { + fprintf(stderr, "%d %d %d\n%s\n", error.line, error.column, error.position, + error.text); + return 1; + } + + json_dumpf(json, stdout, flags); + json_decref(json); + + return 0; +} + +int main(int argc, char *argv[]) { + int i; + char *test_path = NULL; + +#ifdef HAVE_SETLOCALE + setlocale(LC_ALL, ""); +#endif + + if (argc < 2) { + goto usage; + } + + for (i = 1; i < argc; i++) { + if (!strcmp(argv[i], "--strip")) + conf.strip = 1; + else if (!strcmp(argv[i], "--env")) + conf.use_env = 1; + else + test_path = argv[i]; + } + + if (conf.use_env) + return use_env(); + else { + if (!test_path) + goto usage; + + return use_conf(test_path); + } + +usage: + fprintf(stderr, "argc =%d\n", argc); + fprintf(stderr, "usage: %s [--strip] [--env] test_dir\n", argv[0]); + return 2; +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/.gitignore b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/.gitignore new file mode 100644 index 000000000..7fbb8677b --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/.gitignore @@ -0,0 +1 @@ +json_load_dump_fuzzer diff --git a/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/Makefile.am b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/Makefile.am new file mode 100644 index 000000000..a2e802e86 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/Makefile.am @@ -0,0 +1,32 @@ +AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src +LDADD = $(top_builddir)/src/libjansson.la + +if USE_OSSFUZZ_FLAG +FUZZ_FLAG = $(LIB_FUZZING_ENGINE) +else +if USE_OSSFUZZ_STATIC +LDADD += $(LIB_FUZZING_ENGINE) +FUZZ_FLAG = +else +LDADD += libstandaloneengine.a +FUZZ_FLAG = +endif +endif + +noinst_PROGRAMS = +noinst_LIBRARIES = + +if USE_OSSFUZZERS +noinst_PROGRAMS += \ + json_load_dump_fuzzer + +noinst_LIBRARIES += \ + libstandaloneengine.a +endif + +json_load_dump_fuzzer_SOURCES = json_load_dump_fuzzer.cc testinput.h +json_load_dump_fuzzer_CXXFLAGS = $(AM_CXXFLAGS) $(FUZZ_FLAG) +json_load_dump_fuzzer_LDFLAGS = $(AM_LDFLAGS) -static + +libstandaloneengine_a_SOURCES = standaloneengine.cc +libstandaloneengine_a_CXXFLAGS = $(AM_CXXFLAGS) diff --git a/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/json_load_dump_fuzzer.cc b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/json_load_dump_fuzzer.cc new file mode 100644 index 000000000..bc3844e75 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/json_load_dump_fuzzer.cc @@ -0,0 +1,132 @@ +#include <stdint.h> +#include <stdlib.h> +#include <sys/types.h> +#include <inttypes.h> + +#include "jansson.h" + +static int enable_diags; + +#define FUZZ_DEBUG(FMT, ...) \ + if (enable_diags) \ + { \ + fprintf(stderr, FMT, ##__VA_ARGS__); \ + fprintf(stderr, "\n"); \ + } + + +static int json_dump_counter(const char *buffer, size_t size, void *data) +{ + uint64_t *counter = reinterpret_cast<uint64_t *>(data); + *counter += size; + return 0; +} + + +#define NUM_COMMAND_BYTES (sizeof(size_t) + sizeof(size_t) + 1) + +#define FUZZ_DUMP_CALLBACK 0x00 +#define FUZZ_DUMP_STRING 0x01 + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + json_error_t error; + unsigned char dump_mode; + + // Enable or disable diagnostics based on the FUZZ_VERBOSE environment flag. + enable_diags = (getenv("FUZZ_VERBOSE") != NULL); + + FUZZ_DEBUG("Input data length: %zd", size); + + if (size < NUM_COMMAND_BYTES) + { + return 0; + } + + // Use the first sizeof(size_t) bytes as load flags. + size_t load_flags = *(const size_t*)data; + data += sizeof(size_t); + + FUZZ_DEBUG("load_flags: 0x%zx\n" + "& JSON_REJECT_DUPLICATES = 0x%zx\n" + "& JSON_DECODE_ANY = 0x%zx\n" + "& JSON_DISABLE_EOF_CHECK = 0x%zx\n" + "& JSON_DECODE_INT_AS_REAL = 0x%zx\n" + "& JSON_ALLOW_NUL = 0x%zx\n", + load_flags, + load_flags & JSON_REJECT_DUPLICATES, + load_flags & JSON_DECODE_ANY, + load_flags & JSON_DISABLE_EOF_CHECK, + load_flags & JSON_DECODE_INT_AS_REAL, + load_flags & JSON_ALLOW_NUL); + + // Use the next sizeof(size_t) bytes as dump flags. + size_t dump_flags = *(const size_t*)data; + data += sizeof(size_t); + + FUZZ_DEBUG("dump_flags: 0x%zx\n" + "& JSON_MAX_INDENT = 0x%zx\n" + "& JSON_COMPACT = 0x%zx\n" + "& JSON_ENSURE_ASCII = 0x%zx\n" + "& JSON_SORT_KEYS = 0x%zx\n" + "& JSON_PRESERVE_ORDER = 0x%zx\n" + "& JSON_ENCODE_ANY = 0x%zx\n" + "& JSON_ESCAPE_SLASH = 0x%zx\n" + "& JSON_REAL_PRECISION = 0x%zx\n" + "& JSON_EMBED = 0x%zx\n", + dump_flags, + dump_flags & JSON_MAX_INDENT, + dump_flags & JSON_COMPACT, + dump_flags & JSON_ENSURE_ASCII, + dump_flags & JSON_SORT_KEYS, + dump_flags & JSON_PRESERVE_ORDER, + dump_flags & JSON_ENCODE_ANY, + dump_flags & JSON_ESCAPE_SLASH, + ((dump_flags >> 11) & 0x1F) << 11, + dump_flags & JSON_EMBED); + + // Use the next byte as the dump mode. + dump_mode = data[0]; + data++; + + FUZZ_DEBUG("dump_mode: 0x%x", (unsigned int)dump_mode); + + // Remove the command bytes from the size total. + size -= NUM_COMMAND_BYTES; + + // Attempt to load the remainder of the data with the given load flags. + const char* text = reinterpret_cast<const char *>(data); + json_t* jobj = json_loadb(text, size, load_flags, &error); + + if (jobj == NULL) + { + return 0; + } + + if (dump_mode & FUZZ_DUMP_STRING) + { + // Dump as a string. Remove indents so that we don't run out of memory. + char *out = json_dumps(jobj, dump_flags & ~JSON_MAX_INDENT); + if (out != NULL) + { + free(out); + } + } + else + { + // Default is callback mode. + // + // Attempt to dump the loaded json object with the given dump flags. + uint64_t counter = 0; + + json_dump_callback(jobj, json_dump_counter, &counter, dump_flags); + FUZZ_DEBUG("Counter function counted %" PRIu64 " bytes.", counter); + } + + if (jobj) + { + json_decref(jobj); + } + + return 0; +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/ossfuzz.sh b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/ossfuzz.sh new file mode 100755 index 000000000..59740c253 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/ossfuzz.sh @@ -0,0 +1,30 @@ +#!/bin/bash -eu + +# This script is called by the oss-fuzz main project when compiling the fuzz +# targets. This script is regression tested by travisoss.sh. + +# Save off the current folder as the build root. +export BUILD_ROOT=$PWD + +echo "CC: $CC" +echo "CXX: $CXX" +echo "LIB_FUZZING_ENGINE: $LIB_FUZZING_ENGINE" +echo "CFLAGS: $CFLAGS" +echo "CXXFLAGS: $CXXFLAGS" +echo "OUT: $OUT" + +export MAKEFLAGS+="-j$(nproc)" + +# Install dependencies +apt-get -y install automake libtool + +# Compile the fuzzer. +autoreconf -i +./configure --enable-ossfuzzers +make + +# Copy the fuzzer to the output directory. +cp -v test/ossfuzz/json_load_dump_fuzzer $OUT/ + +# Zip up all input files to use as a test corpus +find test/suites -name "input" -print | zip $OUT/json_load_dump_fuzzer_seed_corpus.zip -@ diff --git a/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/standaloneengine.cc b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/standaloneengine.cc new file mode 100644 index 000000000..175360e4a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/standaloneengine.cc @@ -0,0 +1,74 @@ +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> + +#include "testinput.h" + +/** + * Main procedure for standalone fuzzing engine. + * + * Reads filenames from the argument array. For each filename, read the file + * into memory and then call the fuzzing interface with the data. + */ +int main(int argc, char **argv) +{ + int ii; + for(ii = 1; ii < argc; ii++) + { + FILE *infile; + printf("[%s] ", argv[ii]); + + /* Try and open the file. */ + infile = fopen(argv[ii], "rb"); + if(infile) + { + uint8_t *buffer = NULL; + size_t buffer_len; + + printf("Opened.. "); + + /* Get the length of the file. */ + fseek(infile, 0L, SEEK_END); + buffer_len = ftell(infile); + + /* Reset the file indicator to the beginning of the file. */ + fseek(infile, 0L, SEEK_SET); + + /* Allocate a buffer for the file contents. */ + buffer = (uint8_t *)calloc(buffer_len, sizeof(uint8_t)); + if(buffer) + { + /* Read all the text from the file into the buffer. */ + fread(buffer, sizeof(uint8_t), buffer_len, infile); + printf("Read %zu bytes, fuzzing.. ", buffer_len); + + /* Call the fuzzer with the data. */ + LLVMFuzzerTestOneInput(buffer, buffer_len); + + printf("complete !!"); + + /* Free the buffer as it's no longer needed. */ + free(buffer); + buffer = NULL; + } + else + { + fprintf(stderr, + "[%s] Failed to allocate %zu bytes \n", + argv[ii], + buffer_len); + } + + /* Close the file as it's no longer needed. */ + fclose(infile); + infile = NULL; + } + else + { + /* Failed to open the file. Maybe wrong name or wrong permissions? */ + fprintf(stderr, "[%s] Open failed. \n", argv[ii]); + } + + printf("\n"); + } +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/testinput.h b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/testinput.h new file mode 100644 index 000000000..6ab9b515e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/testinput.h @@ -0,0 +1,3 @@ +#include <inttypes.h> + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size); diff --git a/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/travisoss.sh b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/travisoss.sh new file mode 100755 index 000000000..ddcfa075a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/ossfuzz/travisoss.sh @@ -0,0 +1,38 @@ +#!/bin/bash + +set -ex + +PROJECT_NAME=jansson + +# Clone the oss-fuzz repository +git clone https://github.com/google/oss-fuzz.git /tmp/ossfuzz + +if [[ ! -d /tmp/ossfuzz/projects/${PROJECT_NAME} ]] +then + echo "Could not find the ${PROJECT_NAME} project in ossfuzz" + + # Exit with a success code while the jansson project is not expected to exist + # on oss-fuzz. + exit 0 +fi + +# Work out which repo to clone from, inside Docker +if [[ ${TRAVIS_PULL_REQUEST} != "false" ]] +then + # Pull-request branch + REPO=${TRAVIS_PULL_REQUEST_SLUG} + BRANCH=${TRAVIS_PULL_REQUEST_BRANCH} +else + # Push build. + REPO=${TRAVIS_REPO_SLUG} + BRANCH=${TRAVIS_BRANCH} +fi + +# Modify the oss-fuzz Dockerfile so that we're checking out the current branch on travis. +sed -i "s@https://github.com/akheron/jansson.git@-b ${BRANCH} https://github.com/${REPO}.git@" /tmp/ossfuzz/projects/${PROJECT_NAME}/Dockerfile + +# Try and build the fuzzers +pushd /tmp/ossfuzz +python infra/helper.py build_image --pull ${PROJECT_NAME} +python infra/helper.py build_fuzzers ${PROJECT_NAME} +popd diff --git a/src/fluent-bit/lib/jansson-e23f558/test/run-suites b/src/fluent-bit/lib/jansson-e23f558/test/run-suites new file mode 100755 index 000000000..fd1b89b5a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/run-suites @@ -0,0 +1,50 @@ +#!/bin/sh + +while [ -n "$1" ]; do + suite=$1 + if [ -x $top_srcdir/test/suites/$suite/run ]; then + SUITES="$SUITES $suite" + else + echo "No such suite: $suite" + exit 1 + fi + shift +done + +if [ -z "$SUITES" ]; then + suitedirs=$top_srcdir/test/suites/* + for suitedir in $suitedirs; do + if [ -d $suitedir ]; then + SUITES="$SUITES `basename $suitedir`" + fi + done +fi + +[ -z "$STOP" ] && STOP=0 + +suites_srcdir=$top_srcdir/test/suites +suites_builddir=suites +scriptdir=$top_srcdir/test/scripts +logdir=logs +bindir=bin +export suites_srcdir suites_builddir scriptdir logdir bindir + +passed=0 +failed=0 +for suite in $SUITES; do + echo "Suite: $suite" + if $suites_srcdir/$suite/run $suite; then + passed=`expr $passed + 1` + else + failed=`expr $failed + 1` + [ $STOP -eq 1 ] && break + fi +done + +if [ $failed -gt 0 ]; then + echo "$failed of `expr $passed + $failed` test suites failed" + exit 1 +else + echo "$passed test suites passed" + rm -rf $logdir +fi diff --git a/src/fluent-bit/lib/jansson-e23f558/test/scripts/run-tests.sh b/src/fluent-bit/lib/jansson-e23f558/test/scripts/run-tests.sh new file mode 100644 index 000000000..f980a7657 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/scripts/run-tests.sh @@ -0,0 +1,100 @@ +# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> +# +# Jansson is free software; you can redistribute it and/or modify +# it under the terms of the MIT license. See LICENSE for details. + +die() { + echo "$1" >&2 + exit 1 +} + +[ -n "$1" ] || die "Usage: $0 suite-name" +[ -n "$bindir" ] || die "Set bindir" +[ -n "$logdir" ] || die "Set logdir" +[ -n "$scriptdir" ] || die "Set scriptdir" +[ -n "$suites_srcdir" ] || die "Set suites_srcdir" +[ -n "$suites_builddir" ] || die "Set suites_builddir" + +json_process=$bindir/json_process + +suite_name=$1 +suite_srcdir=$suites_srcdir/$suite_name +suite_builddir=$suites_builddir/$suite_name +suite_log=$logdir/$suite_name + +[ -z "$VERBOSE" ] && VERBOSE=0 +[ -z "$STOP" ] && STOP=0 + +. $scriptdir/valgrind.sh + +rm -rf $suite_log +mkdir -p $suite_log + +for test_path in $suite_srcdir/*; do + test_name=$(basename $test_path) + test_builddir=$suite_builddir/$test_name + test_log=$suite_log/$test_name + + [ "$test_name" = "run" ] && continue + is_test || continue + + rm -rf $test_log + mkdir -p $test_log + if [ $VERBOSE -eq 1 ]; then + printf '%s... ' "$test_name" + fi + + run_test + case $? in + 0) + # Success + if [ $VERBOSE -eq 1 ]; then + printf 'ok\n' + else + printf '.' + fi + rm -rf $test_log + ;; + + 77) + # Skip + if [ $VERBOSE -eq 1 ]; then + printf 'skipped\n' + else + printf 'S' + fi + rm -rf $test_log + ;; + + *) + # Failure + if [ $VERBOSE -eq 1 ]; then + printf 'FAILED\n' + else + printf 'F' + fi + + [ $STOP -eq 1 ] && break + ;; + esac +done + +if [ $VERBOSE -eq 0 ]; then + printf '\n' +fi + +if [ -n "$(ls -A $suite_log)" ]; then + for test_log in $suite_log/*; do + test_name=$(basename $test_log) + test_path=$suite_srcdir/$test_name + echo "=================================================================" + echo "$suite_name/$test_name" + echo "=================================================================" + show_error + echo + done + echo "=================================================================" + exit 1 +else + rm -rf $suite_log +fi diff --git a/src/fluent-bit/lib/jansson-e23f558/test/scripts/valgrind.sh b/src/fluent-bit/lib/jansson-e23f558/test/scripts/valgrind.sh new file mode 100644 index 000000000..afbdcee15 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/scripts/valgrind.sh @@ -0,0 +1,35 @@ +# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> +# +# Jansson is free software; you can redistribute it and/or modify +# it under the terms of the MIT license. See LICENSE for details. + +[ -z "$VALGRIND" ] && VALGRIND=0 + +VALGRIND_CMDLINE="valgrind --leak-check=full --show-reachable=yes --track-origins=yes -q" + +if [ $VALGRIND -eq 1 ]; then + test_runner="$VALGRIND_CMDLINE" + json_process="$VALGRIND_CMDLINE $json_process" +else + test_runner="" +fi + +valgrind_check() { + if [ $VALGRIND -eq 1 ]; then + # Check for Valgrind error output. The valgrind option + # --error-exitcode is not enough because Valgrind doesn't + # think unfreed allocs are errors. + if grep -E -q '^==[0-9]+== ' $1; then + touch $test_log/valgrind_error + return 1 + fi + fi +} + +valgrind_show_error() { + if [ $VALGRIND -eq 1 -a -f $test_log/valgrind_error ]; then + echo "valgrind detected an error" + return 0 + fi + return 1 +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/.gitattributes b/src/fluent-bit/lib/jansson-e23f558/test/suites/.gitattributes new file mode 100644 index 000000000..68d88612c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/.gitattributes @@ -0,0 +1,2 @@ +api/ text=auto +* text eol=lf
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/Makefile.am b/src/fluent-bit/lib/jansson-e23f558/test/suites/Makefile.am new file mode 100644 index 000000000..a53eb07f1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/Makefile.am @@ -0,0 +1,2 @@ +SUBDIRS = api +EXTRA_DIST = invalid invalid-unicode valid diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/Makefile.am b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/Makefile.am new file mode 100644 index 000000000..2bc638b82 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/Makefile.am @@ -0,0 +1,42 @@ +EXTRA_DIST = run check-exports + +check_PROGRAMS = \ + test_array \ + test_chaos \ + test_copy \ + test_dump \ + test_dump_callback \ + test_equal \ + test_fixed_size \ + test_load \ + test_load_callback \ + test_loadb \ + test_memory_funcs \ + test_number \ + test_object \ + test_pack \ + test_simple \ + test_sprintf \ + test_unpack \ + test_version + +test_array_SOURCES = test_array.c util.h +test_chaos_SOURCES = test_chaos.c util.h +test_copy_SOURCES = test_copy.c util.h +test_dump_SOURCES = test_dump.c util.h +test_dump_callback_SOURCES = test_dump_callback.c util.h +test_fixed_size_SOURCES = test_fixed_size.c util.h +test_load_SOURCES = test_load.c util.h +test_loadb_SOURCES = test_loadb.c util.h +test_memory_funcs_SOURCES = test_memory_funcs.c util.h +test_number_SOURCES = test_number.c util.h +test_object_SOURCES = test_object.c util.h +test_pack_SOURCES = test_pack.c util.h +test_simple_SOURCES = test_simple.c util.h +test_sprintf_SOURCES = test_sprintf.c util.h +test_unpack_SOURCES = test_unpack.c util.h +test_version_SOURCES = test_version.c util.h + +AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src +LDFLAGS = -static # for speed and Valgrind +LDADD = $(top_builddir)/src/libjansson.la diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/check-exports b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/check-exports new file mode 100755 index 000000000..5c82064c1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/check-exports @@ -0,0 +1,23 @@ +#!/bin/sh +# +# This test checks that libjansson.so exports the correct symbols. +# + +SOFILE="../src/.libs/libjansson.so" + +# The list of symbols, which the shared object should export, is read +# from the def file, which is used in Windows builds +grep 'json_\|jansson_' $top_srcdir/src/jansson.def \ + | sed -e 's/ //g' \ + | sort \ + >$test_log/exports + +nm -D $SOFILE >/dev/null >$test_log/symbols 2>/dev/null \ + || exit 77 # Skip if "nm -D" doesn't seem to work + +grep ' [DT] ' $test_log/symbols | cut -d' ' -f3 | grep -v '^_' | sed 's/@@libjansson.*//' | sort >$test_log/output + +if ! cmp -s $test_log/exports $test_log/output; then + diff -u $test_log/exports $test_log/output >&2 + exit 1 +fi diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/run new file mode 100755 index 000000000..0c017bca6 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/run @@ -0,0 +1,36 @@ +#!/bin/sh +# +# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> +# +# Jansson is free software; you can redistribute it and/or modify +# it under the terms of the MIT license. See LICENSE for details. + +is_test() { + case "$test_name" in + *.c|check-exports) + return 0 + ;; + *) + return 1 + ;; + esac +} + +run_test() { + if [ "$test_name" = "check-exports" ]; then + test_log=$test_log $test_path >$test_log/stdout 2>$test_log/stderr + else + $test_runner $suite_builddir/${test_name%.c} \ + >$test_log/stdout \ + 2>$test_log/stderr \ + || return 1 + valgrind_check $test_log/stderr || return 1 + fi +} + +show_error() { + valgrind_show_error && return + cat $test_log/stderr +} + +. $top_srcdir/test/scripts/run-tests.sh diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_array.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_array.c new file mode 100644 index 000000000..e5d9d1a19 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_array.c @@ -0,0 +1,484 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> + +static void test_misc(void) { + json_t *array, *five, *seven, *value; + size_t i; + + array = json_array(); + five = json_integer(5); + seven = json_integer(7); + + if (!array) + fail("unable to create array"); + if (!five || !seven) + fail("unable to create integer"); + + if (json_array_size(array) != 0) + fail("empty array has nonzero size"); + + if (!json_array_append(array, NULL)) + fail("able to append NULL"); + + if (json_array_append(array, five)) + fail("unable to append"); + + if (json_array_size(array) != 1) + fail("wrong array size"); + + value = json_array_get(array, 0); + if (!value) + fail("unable to get item"); + if (value != five) + fail("got wrong value"); + + if (json_array_append(array, seven)) + fail("unable to append value"); + + if (json_array_size(array) != 2) + fail("wrong array size"); + + value = json_array_get(array, 1); + if (!value) + fail("unable to get item"); + if (value != seven) + fail("got wrong value"); + + if (json_array_set(array, 0, seven)) + fail("unable to set value"); + + if (!json_array_set(array, 0, NULL)) + fail("able to set NULL"); + + if (json_array_size(array) != 2) + fail("wrong array size"); + + value = json_array_get(array, 0); + if (!value) + fail("unable to get item"); + if (value != seven) + fail("got wrong value"); + + if (json_array_get(array, 2) != NULL) + fail("able to get value out of bounds"); + + if (!json_array_set(array, 2, seven)) + fail("able to set value out of bounds"); + + for (i = 2; i < 30; i++) { + if (json_array_append(array, seven)) + fail("unable to append value"); + + if (json_array_size(array) != i + 1) + fail("wrong array size"); + } + + for (i = 0; i < 30; i++) { + value = json_array_get(array, i); + if (!value) + fail("unable to get item"); + if (value != seven) + fail("got wrong value"); + } + + if (json_array_set_new(array, 15, json_integer(123))) + fail("unable to set new value"); + + value = json_array_get(array, 15); + if (!json_is_integer(value) || json_integer_value(value) != 123) + fail("json_array_set_new works incorrectly"); + + if (!json_array_set_new(array, 15, NULL)) + fail("able to set_new NULL value"); + + if (json_array_append_new(array, json_integer(321))) + fail("unable to append new value"); + + value = json_array_get(array, json_array_size(array) - 1); + if (!json_is_integer(value) || json_integer_value(value) != 321) + fail("json_array_append_new works incorrectly"); + + if (!json_array_append_new(array, NULL)) + fail("able to append_new NULL value"); + + json_decref(five); + json_decref(seven); + json_decref(array); +} + +static void test_insert(void) { + json_t *array, *five, *seven, *eleven, *value; + int i; + + array = json_array(); + five = json_integer(5); + seven = json_integer(7); + eleven = json_integer(11); + + if (!array) + fail("unable to create array"); + if (!five || !seven || !eleven) + fail("unable to create integer"); + + if (!json_array_insert(array, 1, five)) + fail("able to insert value out of bounds"); + + if (json_array_insert(array, 0, five)) + fail("unable to insert value in an empty array"); + + if (json_array_get(array, 0) != five) + fail("json_array_insert works incorrectly"); + + if (json_array_size(array) != 1) + fail("array size is invalid after insertion"); + + if (json_array_insert(array, 1, seven)) + fail("unable to insert value at the end of an array"); + + if (json_array_get(array, 0) != five) + fail("json_array_insert works incorrectly"); + + if (json_array_get(array, 1) != seven) + fail("json_array_insert works incorrectly"); + + if (json_array_size(array) != 2) + fail("array size is invalid after insertion"); + + if (json_array_insert(array, 1, eleven)) + fail("unable to insert value in the middle of an array"); + + if (json_array_get(array, 0) != five) + fail("json_array_insert works incorrectly"); + + if (json_array_get(array, 1) != eleven) + fail("json_array_insert works incorrectly"); + + if (json_array_get(array, 2) != seven) + fail("json_array_insert works incorrectly"); + + if (json_array_size(array) != 3) + fail("array size is invalid after insertion"); + + if (json_array_insert_new(array, 2, json_integer(123))) + fail("unable to insert value in the middle of an array"); + + value = json_array_get(array, 2); + if (!json_is_integer(value) || json_integer_value(value) != 123) + fail("json_array_insert_new works incorrectly"); + + if (json_array_size(array) != 4) + fail("array size is invalid after insertion"); + + for (i = 0; i < 20; i++) { + if (json_array_insert(array, 0, seven)) + fail("unable to insert value at the beginning of an array"); + } + + for (i = 0; i < 20; i++) { + if (json_array_get(array, i) != seven) + fail("json_aray_insert works incorrectly"); + } + + if (json_array_size(array) != 24) + fail("array size is invalid after loop insertion"); + + json_decref(five); + json_decref(seven); + json_decref(eleven); + json_decref(array); +} + +static void test_remove(void) { + json_t *array, *five, *seven; + int i; + + array = json_array(); + five = json_integer(5); + seven = json_integer(7); + + if (!array) + fail("unable to create array"); + if (!five) + fail("unable to create integer"); + if (!seven) + fail("unable to create integer"); + + if (!json_array_remove(array, 0)) + fail("able to remove an unexisting index"); + + if (json_array_append(array, five)) + fail("unable to append"); + + if (!json_array_remove(array, 1)) + fail("able to remove an unexisting index"); + + if (json_array_remove(array, 0)) + fail("unable to remove"); + + if (json_array_size(array) != 0) + fail("array size is invalid after removing"); + + if (json_array_append(array, five) || json_array_append(array, seven) || + json_array_append(array, five) || json_array_append(array, seven)) + fail("unable to append"); + + if (json_array_remove(array, 2)) + fail("unable to remove"); + + if (json_array_size(array) != 3) + fail("array size is invalid after removing"); + + if (json_array_get(array, 0) != five || json_array_get(array, 1) != seven || + json_array_get(array, 2) != seven) + fail("remove works incorrectly"); + + json_decref(array); + + array = json_array(); + for (i = 0; i < 4; i++) { + json_array_append(array, five); + json_array_append(array, seven); + } + if (json_array_size(array) != 8) + fail("unable to append 8 items to array"); + + /* Remove an element from a "full" array. */ + json_array_remove(array, 5); + + json_decref(five); + json_decref(seven); + json_decref(array); +} + +static void test_clear(void) { + json_t *array, *five, *seven; + int i; + + array = json_array(); + five = json_integer(5); + seven = json_integer(7); + + if (!array) + fail("unable to create array"); + if (!five || !seven) + fail("unable to create integer"); + + for (i = 0; i < 10; i++) { + if (json_array_append(array, five)) + fail("unable to append"); + } + for (i = 0; i < 10; i++) { + if (json_array_append(array, seven)) + fail("unable to append"); + } + + if (json_array_size(array) != 20) + fail("array size is invalid after appending"); + + if (json_array_clear(array)) + fail("unable to clear"); + + if (json_array_size(array) != 0) + fail("array size is invalid after clearing"); + + json_decref(five); + json_decref(seven); + json_decref(array); +} + +static void test_extend(void) { + json_t *array1, *array2, *five, *seven; + int i; + + array1 = json_array(); + array2 = json_array(); + five = json_integer(5); + seven = json_integer(7); + + if (!array1 || !array2) + fail("unable to create array"); + if (!five || !seven) + fail("unable to create integer"); + + for (i = 0; i < 10; i++) { + if (json_array_append(array1, five)) + fail("unable to append"); + } + for (i = 0; i < 10; i++) { + if (json_array_append(array2, seven)) + fail("unable to append"); + } + + if (json_array_size(array1) != 10 || json_array_size(array2) != 10) + fail("array size is invalid after appending"); + + if (json_array_extend(array1, array2)) + fail("unable to extend"); + + for (i = 0; i < 10; i++) { + if (json_array_get(array1, i) != five) + fail("invalid array contents after extending"); + } + for (i = 10; i < 20; i++) { + if (json_array_get(array1, i) != seven) + fail("invalid array contents after extending"); + } + + json_decref(five); + json_decref(seven); + json_decref(array1); + json_decref(array2); +} + +static void test_circular() { + json_t *array1, *array2; + + /* the simple cases are checked */ + + array1 = json_array(); + if (!array1) + fail("unable to create array"); + + if (json_array_append(array1, array1) == 0) + fail("able to append self"); + + if (json_array_insert(array1, 0, array1) == 0) + fail("able to insert self"); + + if (json_array_append_new(array1, json_true())) + fail("failed to append true"); + + if (json_array_set(array1, 0, array1) == 0) + fail("able to set self"); + + json_decref(array1); + + /* create circular references */ + + array1 = json_array(); + array2 = json_array(); + if (!array1 || !array2) + fail("unable to create array"); + + if (json_array_append(array1, array2) || json_array_append(array2, array1)) + fail("unable to append"); + + /* circularity is detected when dumping */ + if (json_dumps(array1, 0) != NULL) + fail("able to dump circulars"); + + /* decref twice to deal with the circular references */ + json_decref(array1); + json_decref(array2); + json_decref(array1); +} + +static void test_array_foreach() { + size_t index; + json_t *array1, *array2, *value; + + array1 = json_pack("[sisisi]", "foo", 1, "bar", 2, "baz", 3); + array2 = json_array(); + + json_array_foreach(array1, index, value) { json_array_append(array2, value); } + + if (!json_equal(array1, array2)) + fail("json_array_foreach failed to iterate all elements"); + + json_decref(array1); + json_decref(array2); +} + +static void test_bad_args(void) { + json_t *arr = json_array(); + json_t *num = json_integer(1); + + if (!arr || !num) + fail("failed to create required objects"); + + if (json_array_size(NULL) != 0) + fail("NULL array has nonzero size"); + if (json_array_size(num) != 0) + fail("non-array has nonzero array size"); + + if (json_array_get(NULL, 0)) + fail("json_array_get did not return NULL for non-array"); + if (json_array_get(num, 0)) + fail("json_array_get did not return NULL for non-array"); + + if (!json_array_set_new(NULL, 0, json_incref(num))) + fail("json_array_set_new did not return error for non-array"); + if (!json_array_set_new(num, 0, json_incref(num))) + fail("json_array_set_new did not return error for non-array"); + if (!json_array_set_new(arr, 0, NULL)) + fail("json_array_set_new did not return error for NULL value"); + if (!json_array_set_new(arr, 0, json_incref(arr))) + fail("json_array_set_new did not return error for value == array"); + + if (!json_array_remove(NULL, 0)) + fail("json_array_remove did not return error for non-array"); + if (!json_array_remove(num, 0)) + fail("json_array_remove did not return error for non-array"); + + if (!json_array_clear(NULL)) + fail("json_array_clear did not return error for non-array"); + if (!json_array_clear(num)) + fail("json_array_clear did not return error for non-array"); + + if (!json_array_append_new(NULL, json_incref(num))) + fail("json_array_append_new did not return error for non-array"); + if (!json_array_append_new(num, json_incref(num))) + fail("json_array_append_new did not return error for non-array"); + if (!json_array_append_new(arr, NULL)) + fail("json_array_append_new did not return error for NULL value"); + if (!json_array_append_new(arr, json_incref(arr))) + fail("json_array_append_new did not return error for value == array"); + + if (!json_array_insert_new(NULL, 0, json_incref(num))) + fail("json_array_insert_new did not return error for non-array"); + if (!json_array_insert_new(num, 0, json_incref(num))) + fail("json_array_insert_new did not return error for non-array"); + if (!json_array_insert_new(arr, 0, NULL)) + fail("json_array_insert_new did not return error for NULL value"); + if (!json_array_insert_new(arr, 0, json_incref(arr))) + fail("json_array_insert_new did not return error for value == array"); + + if (!json_array_extend(NULL, arr)) + fail("json_array_extend did not return error for first argument " + "non-array"); + if (!json_array_extend(num, arr)) + fail("json_array_extend did not return error for first argument " + "non-array"); + if (!json_array_extend(arr, NULL)) + fail("json_array_extend did not return error for second argument " + "non-array"); + if (!json_array_extend(arr, num)) + fail("json_array_extend did not return error for second argument " + "non-array"); + + if (num->refcount != 1) + fail("unexpected reference count on num"); + if (arr->refcount != 1) + fail("unexpected reference count on arr"); + + json_decref(num); + json_decref(arr); +} + +static void run_tests() { + test_misc(); + test_insert(); + test_remove(); + test_clear(); + test_extend(); + test_circular(); + test_array_foreach(); + test_bad_args(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_chaos.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_chaos.c new file mode 100644 index 000000000..8687243ed --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_chaos.c @@ -0,0 +1,168 @@ +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif + +#include "util.h" +#include <jansson.h> +#include <stdio.h> +#include <string.h> + +static int chaos_pos = 0; +static int chaos_fail = 0; +#define CHAOS_MAX_FAILURE 100 + +void *chaos_malloc(size_t size) { + if (chaos_pos == chaos_fail) + return NULL; + + chaos_pos++; + + return malloc(size); +} + +void chaos_free(void *obj) { free(obj); } + +/* Test all potential allocation failures. */ +#define chaos_loop(condition, code, cleanup) \ + { \ + chaos_pos = chaos_fail = 0; \ + while (condition) { \ + if (chaos_fail > CHAOS_MAX_FAILURE) \ + fail("too many chaos failures"); \ + code chaos_pos = 0; \ + chaos_fail++; \ + } \ + cleanup \ + } + +#define chaos_loop_new_value(json, initcall) \ + chaos_loop(!json, json = initcall;, json_decref(json); json = NULL;) + +int test_unpack() { + int ret = -1; + int v1; + int v2; + json_error_t error; + json_t *root = json_pack("{s:i, s:i, s:i, s:i}", "n1", 1, "n2", 2, "n3", 3, "n4", 4); + + if (!root) + return -1; + + if (!json_unpack_ex(root, &error, JSON_STRICT, "{s:i, s:i}", "n1", &v1, "n2", &v2)) + fail("Unexpected success"); + + if (json_error_code(&error) != json_error_end_of_input_expected) { + if (json_error_code(&error) != json_error_out_of_memory) + fail("Unexpected error code"); + + goto out; + } + + if (strcmp(error.text, "2 object item(s) left unpacked: n3, n4")) + goto out; + + ret = 0; + +out: + json_decref(root); + return ret; +} + +int dump_chaos_callback(const char *buffer, size_t size, void *data) { + json_t *obj = json_object(); + + (void)buffer; + (void)size; + (void)data; + + if (!obj) + return -1; + + json_decref(obj); + + return 0; +} + +static void test_chaos() { + json_malloc_t orig_malloc; + json_free_t orig_free; + json_t *json = NULL; + json_t *obj = json_object(); + json_t *arr1 = json_array(); + json_t *arr2 = json_array(); + json_t *txt = json_string("test"); + json_t *intnum = json_integer(1); + json_t *dblnum = json_real(0.5); + char *dumptxt = NULL; + json_t *dumpobj = json_pack("{s:[iiis], s:s}", "key1", 1, 2, 3, "txt", "key2", "v2"); + int keyno; + + if (!obj || !arr1 || !arr2 || !txt || !intnum || !dblnum || !dumpobj) + fail("failed to allocate basic objects"); + + json_get_alloc_funcs(&orig_malloc, &orig_free); + json_set_alloc_funcs(chaos_malloc, chaos_free); + + chaos_loop_new_value(json, json_pack("{s:s}", "key", "value")); + chaos_loop_new_value(json, json_pack("{s:[]}", "key")); + chaos_loop_new_value(json, json_pack("[biIf]", 1, 1, (json_int_t)1, 1.0)); + chaos_loop_new_value(json, json_pack("[s*,s*]", "v1", "v2")); + chaos_loop_new_value(json, json_pack("o", json_incref(txt))); + chaos_loop_new_value(json, json_pack("O", txt)); + chaos_loop_new_value(json, json_pack("s++", "a", "long string to force realloc", + "another long string to force yet another " + "reallocation of the string because " + "that's what we are testing.")); + + chaos_loop(test_unpack(), , ); + + chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1)), + , ); + chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, + JSON_INDENT(1) | JSON_SORT_KEYS), + , ); + chaos_loop(!dumptxt, dumptxt = json_dumps(dumpobj, JSON_COMPACT);, free(dumptxt); + dumptxt = NULL;); + + chaos_loop_new_value(json, json_copy(obj)); + chaos_loop_new_value(json, json_deep_copy(obj)); + + chaos_loop_new_value(json, json_copy(arr1)); + chaos_loop_new_value(json, json_deep_copy(arr1)); + + chaos_loop_new_value(json, json_copy(txt)); + chaos_loop_new_value(json, json_copy(intnum)); + chaos_loop_new_value(json, json_copy(dblnum)); + +#define JSON_LOAD_TXT "{\"n\":[1,2,3,4,5,6,7,8,9,10]}" + chaos_loop_new_value(json, json_loads(JSON_LOAD_TXT, 0, NULL)); + chaos_loop_new_value(json, json_loadb(JSON_LOAD_TXT, strlen(JSON_LOAD_TXT), 0, NULL)); + + chaos_loop_new_value(json, json_sprintf("%s", "string")); + + for (keyno = 0; keyno < 100; ++keyno) { +#if !defined(_MSC_VER) || _MSC_VER >= 1900 + /* Skip this test on old Windows compilers. */ + char testkey[10]; + + snprintf(testkey, sizeof(testkey), "test%d", keyno); + chaos_loop(json_object_set_new_nocheck(obj, testkey, json_object()), , ); +#endif + chaos_loop(json_array_append_new(arr1, json_null()), , ); + chaos_loop(json_array_insert_new(arr2, 0, json_null()), , ); + } + + chaos_loop(json_array_extend(arr1, arr2), , ); + chaos_loop(json_string_set_nocheck(txt, "test"), , ); + + json_set_alloc_funcs(orig_malloc, orig_free); + json_decref(obj); + json_decref(arr1); + json_decref(arr2); + json_decref(txt); + json_decref(intnum); + json_decref(dblnum); + json_decref(dumpobj); +} + +static void run_tests() { test_chaos(); } diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_copy.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_copy.c new file mode 100644 index 000000000..656d98dd7 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_copy.c @@ -0,0 +1,375 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void test_copy_simple(void) { + json_t *value, *copy; + + if (json_copy(NULL)) + fail("copying NULL doesn't return NULL"); + + /* true */ + value = json_true(); + copy = json_copy(value); + if (value != copy) + fail("copying true failed"); + json_decref(value); + json_decref(copy); + + /* false */ + value = json_false(); + copy = json_copy(value); + if (value != copy) + fail("copying false failed"); + json_decref(value); + json_decref(copy); + + /* null */ + value = json_null(); + copy = json_copy(value); + if (value != copy) + fail("copying null failed"); + json_decref(value); + json_decref(copy); + + /* string */ + value = json_string("foo"); + if (!value) + fail("unable to create a string"); + copy = json_copy(value); + if (!copy) + fail("unable to copy a string"); + if (copy == value) + fail("copying a string doesn't copy"); + if (!json_equal(copy, value)) + fail("copying a string produces an inequal copy"); + if (value->refcount != 1 || copy->refcount != 1) + fail("invalid refcounts"); + json_decref(value); + json_decref(copy); + + /* integer */ + value = json_integer(543); + if (!value) + fail("unable to create an integer"); + copy = json_copy(value); + if (!copy) + fail("unable to copy an integer"); + if (copy == value) + fail("copying an integer doesn't copy"); + if (!json_equal(copy, value)) + fail("copying an integer produces an inequal copy"); + if (value->refcount != 1 || copy->refcount != 1) + fail("invalid refcounts"); + json_decref(value); + json_decref(copy); + + /* real */ + value = json_real(123e9); + if (!value) + fail("unable to create a real"); + copy = json_copy(value); + if (!copy) + fail("unable to copy a real"); + if (copy == value) + fail("copying a real doesn't copy"); + if (!json_equal(copy, value)) + fail("copying a real produces an inequal copy"); + if (value->refcount != 1 || copy->refcount != 1) + fail("invalid refcounts"); + json_decref(value); + json_decref(copy); +} + +static void test_deep_copy_simple(void) { + json_t *value, *copy; + + if (json_deep_copy(NULL)) + fail("deep copying NULL doesn't return NULL"); + + /* true */ + value = json_true(); + copy = json_deep_copy(value); + if (value != copy) + fail("deep copying true failed"); + json_decref(value); + json_decref(copy); + + /* false */ + value = json_false(); + copy = json_deep_copy(value); + if (value != copy) + fail("deep copying false failed"); + json_decref(value); + json_decref(copy); + + /* null */ + value = json_null(); + copy = json_deep_copy(value); + if (value != copy) + fail("deep copying null failed"); + json_decref(value); + json_decref(copy); + + /* string */ + value = json_string("foo"); + if (!value) + fail("unable to create a string"); + copy = json_deep_copy(value); + if (!copy) + fail("unable to deep copy a string"); + if (copy == value) + fail("deep copying a string doesn't copy"); + if (!json_equal(copy, value)) + fail("deep copying a string produces an inequal copy"); + if (value->refcount != 1 || copy->refcount != 1) + fail("invalid refcounts"); + json_decref(value); + json_decref(copy); + + /* integer */ + value = json_integer(543); + if (!value) + fail("unable to create an integer"); + copy = json_deep_copy(value); + if (!copy) + fail("unable to deep copy an integer"); + if (copy == value) + fail("deep copying an integer doesn't copy"); + if (!json_equal(copy, value)) + fail("deep copying an integer produces an inequal copy"); + if (value->refcount != 1 || copy->refcount != 1) + fail("invalid refcounts"); + json_decref(value); + json_decref(copy); + + /* real */ + value = json_real(123e9); + if (!value) + fail("unable to create a real"); + copy = json_deep_copy(value); + if (!copy) + fail("unable to deep copy a real"); + if (copy == value) + fail("deep copying a real doesn't copy"); + if (!json_equal(copy, value)) + fail("deep copying a real produces an inequal copy"); + if (value->refcount != 1 || copy->refcount != 1) + fail("invalid refcounts"); + json_decref(value); + json_decref(copy); +} + +static void test_copy_array(void) { + const char *json_array_text = "[1, \"foo\", 3.141592, {\"foo\": \"bar\"}]"; + + json_t *array, *copy; + size_t i; + + array = json_loads(json_array_text, 0, NULL); + if (!array) + fail("unable to parse an array"); + + copy = json_copy(array); + if (!copy) + fail("unable to copy an array"); + if (copy == array) + fail("copying an array doesn't copy"); + if (!json_equal(copy, array)) + fail("copying an array produces an inequal copy"); + + for (i = 0; i < json_array_size(copy); i++) { + if (json_array_get(array, i) != json_array_get(copy, i)) + fail("copying an array modifies its elements"); + } + + json_decref(array); + json_decref(copy); +} + +static void test_deep_copy_array(void) { + const char *json_array_text = "[1, \"foo\", 3.141592, {\"foo\": \"bar\"}]"; + + json_t *array, *copy; + size_t i; + + array = json_loads(json_array_text, 0, NULL); + if (!array) + fail("unable to parse an array"); + + copy = json_deep_copy(array); + if (!copy) + fail("unable to deep copy an array"); + if (copy == array) + fail("deep copying an array doesn't copy"); + if (!json_equal(copy, array)) + fail("deep copying an array produces an inequal copy"); + + for (i = 0; i < json_array_size(copy); i++) { + if (json_array_get(array, i) == json_array_get(copy, i)) + fail("deep copying an array doesn't copy its elements"); + } + + json_decref(array); + json_decref(copy); +} + +static void test_copy_object(void) { + const char *json_object_text = + "{\"foo\": \"bar\", \"a\": 1, \"b\": 3.141592, \"c\": [1,2,3,4]}"; + + const char *keys[] = {"foo", "a", "b", "c"}; + int i; + + json_t *object, *copy; + void *iter; + + object = json_loads(json_object_text, 0, NULL); + if (!object) + fail("unable to parse an object"); + + copy = json_copy(object); + if (!copy) + fail("unable to copy an object"); + if (copy == object) + fail("copying an object doesn't copy"); + if (!json_equal(copy, object)) + fail("copying an object produces an inequal copy"); + + i = 0; + iter = json_object_iter(object); + while (iter) { + const char *key; + json_t *value1, *value2; + + key = json_object_iter_key(iter); + value1 = json_object_iter_value(iter); + value2 = json_object_get(copy, key); + + if (value1 != value2) + fail("copying an object modifies its items"); + + if (strcmp(key, keys[i]) != 0) + fail("copying an object doesn't preserve key order"); + + iter = json_object_iter_next(object, iter); + i++; + } + + json_decref(object); + json_decref(copy); +} + +static void test_deep_copy_object(void) { + const char *json_object_text = + "{\"foo\": \"bar\", \"a\": 1, \"b\": 3.141592, \"c\": [1,2,3,4]}"; + + const char *keys[] = {"foo", "a", "b", "c"}; + int i; + + json_t *object, *copy; + void *iter; + + object = json_loads(json_object_text, 0, NULL); + if (!object) + fail("unable to parse an object"); + + copy = json_deep_copy(object); + if (!copy) + fail("unable to deep copy an object"); + if (copy == object) + fail("deep copying an object doesn't copy"); + if (!json_equal(copy, object)) + fail("deep copying an object produces an inequal copy"); + + i = 0; + iter = json_object_iter(object); + while (iter) { + const char *key; + json_t *value1, *value2; + + key = json_object_iter_key(iter); + value1 = json_object_iter_value(iter); + value2 = json_object_get(copy, key); + + if (value1 == value2) + fail("deep copying an object doesn't copy its items"); + + if (strcmp(key, keys[i]) != 0) + fail("deep copying an object doesn't preserve key order"); + + iter = json_object_iter_next(object, iter); + i++; + } + + json_decref(object); + json_decref(copy); +} + +static void test_deep_copy_circular_references(void) { + /* Construct a JSON object/array with a circular reference: + + object: {"a": {"b": {"c": <circular reference to $.a>}}} + array: [[[<circular reference to the $[0] array>]]] + + Deep copy it, remove the circular reference and deep copy again. + */ + + json_t *json; + json_t *copy; + + json = json_object(); + json_object_set_new(json, "a", json_object()); + json_object_set_new(json_object_get(json, "a"), "b", json_object()); + json_object_set(json_object_get(json_object_get(json, "a"), "b"), "c", + json_object_get(json, "a")); + + copy = json_deep_copy(json); + if (copy) + fail("json_deep_copy copied a circular reference!"); + + json_object_del(json_object_get(json_object_get(json, "a"), "b"), "c"); + + copy = json_deep_copy(json); + if (!copy) + fail("json_deep_copy failed!"); + + json_decref(copy); + json_decref(json); + + json = json_array(); + json_array_append_new(json, json_array()); + json_array_append_new(json_array_get(json, 0), json_array()); + json_array_append(json_array_get(json_array_get(json, 0), 0), + json_array_get(json, 0)); + + copy = json_deep_copy(json); + if (copy) + fail("json_deep_copy copied a circular reference!"); + + json_array_remove(json_array_get(json_array_get(json, 0), 0), 0); + + copy = json_deep_copy(json); + if (!copy) + fail("json_deep_copy failed!"); + + json_decref(copy); + json_decref(json); +} + +static void run_tests() { + test_copy_simple(); + test_deep_copy_simple(); + test_copy_array(); + test_deep_copy_array(); + test_copy_object(); + test_deep_copy_object(); + test_deep_copy_circular_references(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump.c new file mode 100644 index 000000000..e8cb51962 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump.c @@ -0,0 +1,311 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "jansson_private_config.h" + +#include <jansson.h> +#include <string.h> +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif +#include "util.h" +#ifdef __MINGW32__ +#include <fcntl.h> +#define pipe(fds) _pipe(fds, 1024, _O_BINARY) +#endif + +static int encode_null_callback(const char *buffer, size_t size, void *data) { + (void)buffer; + (void)size; + (void)data; + return 0; +} + +static void encode_null() { + if (json_dumps(NULL, JSON_ENCODE_ANY) != NULL) + fail("json_dumps didn't fail for NULL"); + + if (json_dumpb(NULL, NULL, 0, JSON_ENCODE_ANY) != 0) + fail("json_dumpb didn't fail for NULL"); + + if (json_dumpf(NULL, stderr, JSON_ENCODE_ANY) != -1) + fail("json_dumpf didn't fail for NULL"); + +#ifdef HAVE_UNISTD_H + if (json_dumpfd(NULL, STDERR_FILENO, JSON_ENCODE_ANY) != -1) + fail("json_dumpfd didn't fail for NULL"); +#endif + + /* Don't test json_dump_file to avoid creating a file */ + + if (json_dump_callback(NULL, encode_null_callback, NULL, JSON_ENCODE_ANY) != -1) + fail("json_dump_callback didn't fail for NULL"); +} + +static void encode_twice() { + /* Encode an empty object/array, add an item, encode again */ + + json_t *json; + char *result; + + json = json_object(); + result = json_dumps(json, 0); + if (!result || strcmp(result, "{}")) + fail("json_dumps failed"); + free(result); + + json_object_set_new(json, "foo", json_integer(5)); + result = json_dumps(json, 0); + if (!result || strcmp(result, "{\"foo\": 5}")) + fail("json_dumps failed"); + free(result); + + json_decref(json); + + json = json_array(); + result = json_dumps(json, 0); + if (!result || strcmp(result, "[]")) + fail("json_dumps failed"); + free(result); + + json_array_append_new(json, json_integer(5)); + result = json_dumps(json, 0); + if (!result || strcmp(result, "[5]")) + fail("json_dumps failed"); + free(result); + + json_decref(json); +} + +static void circular_references() { + /* Construct a JSON object/array with a circular reference: + + object: {"a": {"b": {"c": <circular reference to $.a>}}} + array: [[[<circular reference to the $[0] array>]]] + + Encode it, remove the circular reference and encode again. + */ + + json_t *json; + char *result; + + json = json_object(); + json_object_set_new(json, "a", json_object()); + json_object_set_new(json_object_get(json, "a"), "b", json_object()); + json_object_set(json_object_get(json_object_get(json, "a"), "b"), "c", + json_object_get(json, "a")); + + if (json_dumps(json, 0)) + fail("json_dumps encoded a circular reference!"); + + json_object_del(json_object_get(json_object_get(json, "a"), "b"), "c"); + + result = json_dumps(json, 0); + if (!result || strcmp(result, "{\"a\": {\"b\": {}}}")) + fail("json_dumps failed!"); + free(result); + + json_decref(json); + + json = json_array(); + json_array_append_new(json, json_array()); + json_array_append_new(json_array_get(json, 0), json_array()); + json_array_append(json_array_get(json_array_get(json, 0), 0), + json_array_get(json, 0)); + + if (json_dumps(json, 0)) + fail("json_dumps encoded a circular reference!"); + + json_array_remove(json_array_get(json_array_get(json, 0), 0), 0); + + result = json_dumps(json, 0); + if (!result || strcmp(result, "[[[]]]")) + fail("json_dumps failed!"); + free(result); + + json_decref(json); +} + +static void encode_other_than_array_or_object() { + /* Encoding anything other than array or object should only + * succeed if the JSON_ENCODE_ANY flag is used */ + + json_t *json; + char *result; + + json = json_string("foo"); + if (json_dumps(json, 0) != NULL) + fail("json_dumps encoded a string!"); + if (json_dumpf(json, NULL, 0) == 0) + fail("json_dumpf encoded a string!"); + if (json_dumpfd(json, -1, 0) == 0) + fail("json_dumpfd encoded a string!"); + + result = json_dumps(json, JSON_ENCODE_ANY); + if (!result || strcmp(result, "\"foo\"") != 0) + fail("json_dumps failed to encode a string with JSON_ENCODE_ANY"); + + free(result); + json_decref(json); + + json = json_integer(42); + if (json_dumps(json, 0) != NULL) + fail("json_dumps encoded an integer!"); + if (json_dumpf(json, NULL, 0) == 0) + fail("json_dumpf encoded an integer!"); + if (json_dumpfd(json, -1, 0) == 0) + fail("json_dumpfd encoded an integer!"); + + result = json_dumps(json, JSON_ENCODE_ANY); + if (!result || strcmp(result, "42") != 0) + fail("json_dumps failed to encode an integer with JSON_ENCODE_ANY"); + + free(result); + json_decref(json); +} + +static void escape_slashes() { + /* Test dump escaping slashes */ + + json_t *json; + char *result; + + json = json_object(); + json_object_set_new(json, "url", json_string("https://github.com/akheron/jansson")); + + result = json_dumps(json, 0); + if (!result || strcmp(result, "{\"url\": \"https://github.com/akheron/jansson\"}")) + fail("json_dumps failed to not escape slashes"); + + free(result); + + result = json_dumps(json, JSON_ESCAPE_SLASH); + if (!result || + strcmp(result, "{\"url\": \"https:\\/\\/github.com\\/akheron\\/jansson\"}")) + fail("json_dumps failed to escape slashes"); + + free(result); + json_decref(json); +} + +static void encode_nul_byte() { + json_t *json; + char *result; + + json = json_stringn("nul byte \0 in string", 20); + result = json_dumps(json, JSON_ENCODE_ANY); + if (!result || memcmp(result, "\"nul byte \\u0000 in string\"", 27)) + fail("json_dumps failed to dump an embedded NUL byte"); + + free(result); + json_decref(json); +} + +static void dump_file() { + json_t *json; + int result; + + result = json_dump_file(NULL, "", 0); + if (result != -1) + fail("json_dump_file succeeded with invalid args"); + + json = json_object(); + result = json_dump_file(json, "json_dump_file.json", 0); + if (result != 0) + fail("json_dump_file failed"); + + json_decref(json); + remove("json_dump_file.json"); +} + +static void dumpb() { + char buf[2]; + json_t *obj; + size_t size; + + obj = json_object(); + + size = json_dumpb(obj, buf, sizeof(buf), 0); + if (size != 2 || strncmp(buf, "{}", 2)) + fail("json_dumpb failed"); + + json_decref(obj); + obj = json_pack("{s:s}", "foo", "bar"); + + size = json_dumpb(obj, buf, sizeof(buf), JSON_COMPACT); + if (size != 13) + fail("json_dumpb size check failed"); + + json_decref(obj); +} + +static void dumpfd() { +#ifdef HAVE_UNISTD_H + int fds[2] = {-1, -1}; + json_t *a, *b; + + if (pipe(fds)) + fail("pipe() failed"); + + a = json_pack("{s:s}", "foo", "bar"); + + if (json_dumpfd(a, fds[1], 0)) + fail("json_dumpfd() failed"); + close(fds[1]); + + b = json_loadfd(fds[0], 0, NULL); + if (!b) + fail("json_loadfd() failed"); + close(fds[0]); + + if (!json_equal(a, b)) + fail("json_equal() failed for fd test"); + + json_decref(a); + json_decref(b); +#endif +} + +static void embed() { + static const char *plains[] = {"{\"bar\":[],\"foo\":{}}", "[[],{}]", "{}", "[]", + NULL}; + + size_t i; + + for (i = 0; plains[i]; i++) { + const char *plain = plains[i]; + json_t *parse = NULL; + char *embed = NULL; + size_t psize = 0; + size_t esize = 0; + + psize = strlen(plain) - 2; + embed = calloc(1, psize); + parse = json_loads(plain, 0, NULL); + esize = + json_dumpb(parse, embed, psize, JSON_COMPACT | JSON_SORT_KEYS | JSON_EMBED); + json_decref(parse); + if (esize != psize) + fail("json_dumpb(JSON_EMBED) returned an invalid size"); + if (strncmp(plain + 1, embed, esize) != 0) + fail("json_dumps(JSON_EMBED) returned an invalid value"); + free(embed); + } +} + +static void run_tests() { + encode_null(); + encode_twice(); + circular_references(); + encode_other_than_array_or_object(); + escape_slashes(); + encode_nul_byte(); + dump_file(); + dumpb(); + dumpfd(); + embed(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump_callback.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump_callback.c new file mode 100644 index 000000000..80ea00845 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_dump_callback.c @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <stdlib.h> +#include <string.h> + +struct my_sink { + char *buf; + size_t off; + size_t cap; +}; + +static int my_writer(const char *buffer, size_t len, void *data) { + struct my_sink *s = data; + if (len > s->cap - s->off) { + return -1; + } + memcpy(s->buf + s->off, buffer, len); + s->off += len; + return 0; +} + +static void run_tests() { + struct my_sink s; + json_t *json; + const char str[] = "[\"A\", {\"B\": \"C\", \"e\": false}, 1, null, \"foo\"]"; + char *dumped_to_string; + + json = json_loads(str, 0, NULL); + if (!json) { + fail("json_loads failed"); + } + + dumped_to_string = json_dumps(json, 0); + if (!dumped_to_string) { + json_decref(json); + fail("json_dumps failed"); + } + + s.off = 0; + s.cap = strlen(dumped_to_string); + s.buf = malloc(s.cap); + if (!s.buf) { + json_decref(json); + free(dumped_to_string); + fail("malloc failed"); + } + + if (json_dump_callback(json, my_writer, &s, 0) == -1) { + json_decref(json); + free(dumped_to_string); + free(s.buf); + fail("json_dump_callback failed on an exact-length sink buffer"); + } + + if (strncmp(dumped_to_string, s.buf, s.off) != 0) { + json_decref(json); + free(dumped_to_string); + free(s.buf); + fail("json_dump_callback and json_dumps did not produce identical " + "output"); + } + + s.off = 1; + if (json_dump_callback(json, my_writer, &s, 0) != -1) { + json_decref(json); + free(dumped_to_string); + free(s.buf); + fail("json_dump_callback succeeded on a short buffer when it should " + "have failed"); + } + + json_decref(json); + free(dumped_to_string); + free(s.buf); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_equal.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_equal.c new file mode 100644 index 000000000..d068b7bf8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_equal.c @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> + +static void test_equal_simple() { + json_t *value1, *value2; + + if (json_equal(NULL, NULL)) + fail("json_equal fails for two NULLs"); + + value1 = json_true(); + if (json_equal(value1, NULL) || json_equal(NULL, value1)) + fail("json_equal fails for NULL"); + + /* this covers true, false and null as they are singletons */ + if (!json_equal(value1, value1)) + fail("identical objects are not equal"); + json_decref(value1); + + /* integer */ + value1 = json_integer(1); + value2 = json_integer(1); + if (!value1 || !value2) + fail("unable to create integers"); + if (!json_equal(value1, value2)) + fail("json_equal fails for two equal integers"); + json_decref(value2); + + value2 = json_integer(2); + if (!value2) + fail("unable to create an integer"); + if (json_equal(value1, value2)) + fail("json_equal fails for two inequal integers"); + + json_decref(value1); + json_decref(value2); + + /* real */ + value1 = json_real(1.2); + value2 = json_real(1.2); + if (!value1 || !value2) + fail("unable to create reals"); + if (!json_equal(value1, value2)) + fail("json_equal fails for two equal reals"); + json_decref(value2); + + value2 = json_real(3.141592); + if (!value2) + fail("unable to create an real"); + if (json_equal(value1, value2)) + fail("json_equal fails for two inequal reals"); + + json_decref(value1); + json_decref(value2); + + /* string */ + value1 = json_string("foo"); + value2 = json_string("foo"); + if (!value1 || !value2) + fail("unable to create strings"); + if (!json_equal(value1, value2)) + fail("json_equal fails for two equal strings"); + json_decref(value2); + + value2 = json_string("bar"); + if (!value2) + fail("unable to create an string"); + if (json_equal(value1, value2)) + fail("json_equal fails for two inequal strings"); + json_decref(value2); + + value2 = json_string("bar2"); + if (!value2) + fail("unable to create an string"); + if (json_equal(value1, value2)) + fail("json_equal fails for two inequal length strings"); + + json_decref(value1); + json_decref(value2); +} + +static void test_equal_array() { + json_t *array1, *array2; + + array1 = json_array(); + array2 = json_array(); + if (!array1 || !array2) + fail("unable to create arrays"); + + if (!json_equal(array1, array2)) + fail("json_equal fails for two empty arrays"); + + json_array_append_new(array1, json_integer(1)); + json_array_append_new(array2, json_integer(1)); + json_array_append_new(array1, json_string("foo")); + json_array_append_new(array2, json_string("foo")); + json_array_append_new(array1, json_integer(2)); + json_array_append_new(array2, json_integer(2)); + if (!json_equal(array1, array2)) + fail("json_equal fails for two equal arrays"); + + json_array_remove(array2, 2); + if (json_equal(array1, array2)) + fail("json_equal fails for two inequal arrays"); + + json_array_append_new(array2, json_integer(3)); + if (json_equal(array1, array2)) + fail("json_equal fails for two inequal arrays"); + + json_decref(array1); + json_decref(array2); +} + +static void test_equal_object() { + json_t *object1, *object2; + + object1 = json_object(); + object2 = json_object(); + if (!object1 || !object2) + fail("unable to create objects"); + + if (!json_equal(object1, object2)) + fail("json_equal fails for two empty objects"); + + json_object_set_new(object1, "a", json_integer(1)); + json_object_set_new(object2, "a", json_integer(1)); + json_object_set_new(object1, "b", json_string("foo")); + json_object_set_new(object2, "b", json_string("foo")); + json_object_set_new(object1, "c", json_integer(2)); + json_object_set_new(object2, "c", json_integer(2)); + if (!json_equal(object1, object2)) + fail("json_equal fails for two equal objects"); + + json_object_del(object2, "c"); + if (json_equal(object1, object2)) + fail("json_equal fails for two inequal objects"); + + json_object_set_new(object2, "c", json_integer(3)); + if (json_equal(object1, object2)) + fail("json_equal fails for two inequal objects"); + + json_object_del(object2, "c"); + json_object_set_new(object2, "d", json_integer(2)); + if (json_equal(object1, object2)) + fail("json_equal fails for two inequal objects"); + + json_decref(object1); + json_decref(object2); +} + +static void test_equal_complex() { + json_t *value1, *value2, *value3; + + const char *complex_json = "{" + " \"integer\": 1, " + " \"real\": 3.141592, " + " \"string\": \"foobar\", " + " \"true\": true, " + " \"object\": {" + " \"array-in-object\": [1,true,\"foo\",{}]," + " \"object-in-object\": {\"foo\": \"bar\"}" + " }," + " \"array\": [\"foo\", false, null, 1.234]" + "}"; + + value1 = json_loads(complex_json, 0, NULL); + value2 = json_loads(complex_json, 0, NULL); + value3 = json_loads(complex_json, 0, NULL); + if (!value1 || !value2) + fail("unable to parse JSON"); + if (!json_equal(value1, value2)) + fail("json_equal fails for two equal objects"); + + json_array_set_new( + json_object_get(json_object_get(value2, "object"), "array-in-object"), 1, + json_false()); + if (json_equal(value1, value2)) + fail("json_equal fails for two inequal objects"); + + json_object_set_new( + json_object_get(json_object_get(value3, "object"), "object-in-object"), "foo", + json_string("baz")); + if (json_equal(value1, value3)) + fail("json_equal fails for two inequal objects"); + + json_decref(value1); + json_decref(value2); + json_decref(value3); +} + +static void run_tests() { + test_equal_simple(); + test_equal_array(); + test_equal_object(); + test_equal_complex(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_fixed_size.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_fixed_size.c new file mode 100644 index 000000000..4ae9e079c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_fixed_size.c @@ -0,0 +1,228 @@ +/* + * Copyright (c) 2020 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void test_keylen_iterator(json_t *object) { + const char key1[] = {'t', 'e', 's', 't', '1'}; + const char key2[] = {'t', 'e', 's', 't'}; + const char key3[] = {'t', 'e', 's', '\0', 't'}; + const char key4[] = {'t', 'e', 's', 't', '\0'}; + const char *reference_keys[] = {key1, key2, key3, key4}; + const size_t reference_keys_len[] = {sizeof(key1), sizeof(key2), sizeof(key3), + sizeof(key4)}; + size_t index = 0; + json_t *value; + const char *key; + size_t keylen; + + json_object_keylen_foreach(object, key, keylen, value) { + if (keylen != reference_keys_len[index]) + fail("invalid key len in iterator"); + if (memcmp(key, reference_keys[index], reference_keys_len[index]) != 0) + fail("invalid key in iterator"); + + index++; + } +} + +static void test_keylen(void) { + json_t *obj = json_object(); + const char key[] = {'t', 'e', 's', 't', '1'}; + const char key2[] = {'t', 'e', 's', 't'}; + const char key3[] = {'t', 'e', 's', '\0', 't'}; + const char key4[] = {'t', 'e', 's', 't', '\0'}; + + if (json_object_size(obj) != 0) + fail("incorrect json"); + + json_object_set_new_nocheck(obj, "test1", json_true()); + + if (json_object_size(obj) != 1) + fail("incorrect json"); + + if (json_object_getn(obj, key, sizeof(key)) != json_true()) + fail("json_object_getn failed"); + + if (json_object_getn(obj, key2, sizeof(key2)) != NULL) + fail("false positive json_object_getn by key2"); + + if (json_object_setn_nocheck(obj, key2, sizeof(key2), json_false())) + fail("json_object_setn_nocheck for key2 failed"); + + if (json_object_size(obj) != 2) + fail("incorrect json"); + + if (json_object_get(obj, "test") != json_false()) + fail("json_object_setn_nocheck for key2 failed"); + + if (json_object_getn(obj, key2, sizeof(key2)) != json_false()) + fail("json_object_getn by key 2 failed"); + + if (json_object_getn(obj, key3, sizeof(key3)) != NULL) + fail("false positive json_object_getn by key3"); + + if (json_object_setn_nocheck(obj, key3, sizeof(key3), json_false())) + fail("json_object_setn_nocheck for key3 failed"); + + if (json_object_size(obj) != 3) + fail("incorrect json"); + + if (json_object_getn(obj, key3, sizeof(key3)) != json_false()) + fail("json_object_getn by key 3 failed"); + + if (json_object_getn(obj, key4, sizeof(key4)) != NULL) + fail("false positive json_object_getn by key3"); + + if (json_object_setn_nocheck(obj, key4, sizeof(key4), json_false())) + fail("json_object_setn_nocheck for key3 failed"); + + if (json_object_size(obj) != 4) + fail("incorrect json"); + + test_keylen_iterator(obj); + + if (json_object_getn(obj, key4, sizeof(key4)) != json_false()) + fail("json_object_getn by key 3 failed"); + + if (json_object_size(obj) != 4) + fail("incorrect json"); + + if (json_object_deln(obj, key4, sizeof(key4))) + fail("json_object_deln failed"); + if (json_object_getn(obj, key4, sizeof(key4)) != NULL) + fail("json_object_deln failed"); + if (json_object_size(obj) != 3) + fail("incorrect json"); + + if (json_object_deln(obj, key3, sizeof(key3))) + fail("json_object_deln failed"); + if (json_object_getn(obj, key3, sizeof(key3)) != NULL) + fail("json_object_deln failed"); + if (json_object_size(obj) != 2) + fail("incorrect json"); + + if (json_object_deln(obj, key2, sizeof(key2))) + fail("json_object_deln failed"); + if (json_object_getn(obj, key2, sizeof(key2)) != NULL) + fail("json_object_deln failed"); + if (json_object_size(obj) != 1) + fail("incorrect json"); + + if (json_object_deln(obj, key, sizeof(key))) + fail("json_object_deln failed"); + if (json_object_getn(obj, key, sizeof(key)) != NULL) + fail("json_object_deln failed"); + if (json_object_size(obj) != 0) + fail("incorrect json"); + + json_decref(obj); +} + +static void test_invalid_keylen(void) { + json_t *obj = json_object(); + json_t *empty_obj = json_object(); + const char key[] = {'t', 'e', 's', 't', '1'}; + + json_object_set_new_nocheck(obj, "test1", json_true()); + + if (json_object_getn(NULL, key, sizeof(key)) != NULL) + fail("json_object_getn on NULL failed"); + + if (json_object_getn(obj, NULL, sizeof(key)) != NULL) + fail("json_object_getn on NULL failed"); + + if (json_object_getn(obj, key, 0) != NULL) + fail("json_object_getn on NULL failed"); + + if (!json_object_setn_new(obj, NULL, sizeof(key), json_true())) + fail("json_object_setn_new with NULL key failed"); + + if (!json_object_setn_new_nocheck(obj, NULL, sizeof(key), json_true())) + fail("json_object_setn_new_nocheck with NULL key failed"); + + if (!json_object_del(obj, NULL)) + fail("json_object_del with NULL failed"); + + if (!json_object_deln(empty_obj, key, sizeof(key))) + fail("json_object_deln with empty object failed"); + + if (!json_object_deln(obj, key, sizeof(key) - 1)) + fail("json_object_deln with incomplete key failed"); + + json_decref(obj); + json_decref(empty_obj); +} + +static void test_binary_keys(void) { + json_t *obj = json_object(); + int key1 = 0; + int key2 = 1; + + json_object_setn_nocheck(obj, (const char *)&key1, sizeof(key1), json_true()); + json_object_setn_nocheck(obj, (const char *)&key2, sizeof(key2), json_true()); + + if (!json_is_true(json_object_getn(obj, (const char *)&key1, sizeof(key1)))) + fail("cannot get integer key1"); + + if (!json_is_true(json_object_getn(obj, (const char *)&key1, sizeof(key2)))) + fail("cannot get integer key2"); + + if (json_object_size(obj) != 2) + fail("binary object size missmatch"); + + if (json_object_deln(obj, (const char *)&key1, sizeof(key1))) + fail("cannot del integer key1"); + + if (json_object_size(obj) != 1) + fail("binary object size missmatch"); + + if (json_object_deln(obj, (const char *)&key2, sizeof(key2))) + fail("cannot del integer key2"); + + if (json_object_size(obj) != 0) + fail("binary object size missmatch"); + + json_decref(obj); +} + +static void test_dump_order(void) { + json_t *obj = json_object(); + char key1[] = {'k', '\0', '-', '2'}; + char key2[] = {'k', '\0', '-', '1'}; + const char expected_sorted_str[] = + "{\"k\\u0000-1\": \"first\", \"k\\u0000-2\": \"second\"}"; + const char expected_nonsorted_str[] = + "{\"k\\u0000-2\": \"second\", \"k\\u0000-1\": \"first\"}"; + char *out; + + json_object_setn_new_nocheck(obj, key1, sizeof(key1), json_string("second")); + json_object_setn_new_nocheck(obj, key2, sizeof(key2), json_string("first")); + + out = malloc(512); + + json_dumpb(obj, out, 512, 0); + + if (memcmp(expected_nonsorted_str, out, sizeof(expected_nonsorted_str) - 1) != 0) + fail("preserve order failed"); + + json_dumpb(obj, out, 512, JSON_SORT_KEYS); + if (memcmp(expected_sorted_str, out, sizeof(expected_sorted_str) - 1) != 0) + fail("utf-8 sort failed"); + + free(out); + json_decref(obj); +} + +static void run_tests() { + test_keylen(); + test_invalid_keylen(); + test_binary_keys(); + test_dump_order(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load.c new file mode 100644 index 000000000..1c64b0c8d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load.c @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void file_not_found() { + json_t *json; + json_error_t error; + char *pos; + + json = json_load_file("/path/to/nonexistent/file.json", 0, &error); + if (json) + fail("json_load_file returned non-NULL for a nonexistent file"); + if (error.line != -1) + fail("json_load_file returned an invalid line number"); + + /* The error message is locale specific, only check the beginning + of the error message. */ + + pos = strchr(error.text, ':'); + if (!pos) + fail("json_load_file returne an invalid error message"); + + *pos = '\0'; + + if (strcmp(error.text, "unable to open /path/to/nonexistent/file.json") != 0) + fail("json_load_file returned an invalid error message"); + if (json_error_code(&error) != json_error_cannot_open_file) + fail("json_load_file returned an invalid error code"); +} + +static void very_long_file_name() { + json_t *json; + json_error_t error; + + json = json_load_file("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + 0, &error); + if (json) + fail("json_load_file returned non-NULL for a nonexistent file"); + if (error.line != -1) + fail("json_load_file returned an invalid line number"); + + if (strncmp(error.source, "...aaa", 6) != 0) + fail("error source was set incorrectly"); + if (json_error_code(&error) != json_error_cannot_open_file) + fail("error code was set incorrectly"); +} + +static void reject_duplicates() { + json_error_t error; + + if (json_loads("{\"foo\": 1, \"foo\": 2}", JSON_REJECT_DUPLICATES, &error)) + fail("json_loads did not detect a duplicate key"); + check_error(json_error_duplicate_key, "duplicate object key near '\"foo\"'", + "<string>", 1, 16, 16); +} + +static void disable_eof_check() { + json_error_t error; + json_t *json; + + const char *text = "{\"foo\": 1} garbage"; + + if (json_loads(text, 0, &error)) + fail("json_loads did not detect garbage after JSON text"); + check_error(json_error_end_of_input_expected, "end of file expected near 'garbage'", + "<string>", 1, 18, 18); + + json = json_loads(text, JSON_DISABLE_EOF_CHECK, &error); + if (!json) + fail("json_loads failed with JSON_DISABLE_EOF_CHECK"); + + json_decref(json); +} + +static void decode_any() { + json_t *json; + json_error_t error; + + json = json_loads("\"foo\"", JSON_DECODE_ANY, &error); + if (!json || !json_is_string(json)) + fail("json_load decoded any failed - string"); + json_decref(json); + + json = json_loads("42", JSON_DECODE_ANY, &error); + if (!json || !json_is_integer(json)) + fail("json_load decoded any failed - integer"); + json_decref(json); + + json = json_loads("true", JSON_DECODE_ANY, &error); + if (!json || !json_is_true(json)) + fail("json_load decoded any failed - boolean"); + json_decref(json); + + json = json_loads("null", JSON_DECODE_ANY, &error); + if (!json || !json_is_null(json)) + fail("json_load decoded any failed - null"); + json_decref(json); +} + +static void decode_int_as_real() { + json_t *json; + json_error_t error; + +#if JSON_INTEGER_IS_LONG_LONG + const char *imprecise; + json_int_t expected; +#endif + + char big[311]; + + json = json_loads("42", JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error); + if (!json || !json_is_real(json) || json_real_value(json) != 42.0) + fail("json_load decode int as real failed - int"); + json_decref(json); + +#if JSON_INTEGER_IS_LONG_LONG + /* This number cannot be represented exactly by a double */ + imprecise = "9007199254740993"; + expected = 9007199254740992ll; + + json = json_loads(imprecise, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error); + if (!json || !json_is_real(json) || expected != (json_int_t)json_real_value(json)) + fail("json_load decode int as real failed - expected imprecision"); + json_decref(json); +#endif + + /* 1E309 overflows. Here we create 1E309 as a decimal number, i.e. + 1000...(309 zeroes)...0. */ + big[0] = '1'; + memset(big + 1, '0', 309); + big[310] = '\0'; + + json = json_loads(big, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error); + if (json || strcmp(error.text, "real number overflow") != 0 || + json_error_code(&error) != json_error_numeric_overflow) + fail("json_load decode int as real failed - expected overflow"); + json_decref(json); +} + +static void allow_nul() { + const char *text = "\"nul byte \\u0000 in string\""; + const char *expected = "nul byte \0 in string"; + size_t len = 20; + json_t *json; + + json = json_loads(text, JSON_ALLOW_NUL | JSON_DECODE_ANY, NULL); + if (!json || !json_is_string(json)) + fail("unable to decode embedded NUL byte"); + + if (json_string_length(json) != len) + fail("decoder returned wrong string length"); + + if (memcmp(json_string_value(json), expected, len + 1)) + fail("decoder returned wrong string content"); + + json_decref(json); +} + +static void load_wrong_args() { + json_t *json; + json_error_t error; + + json = json_loads(NULL, 0, &error); + if (json) + fail("json_loads should return NULL if the first argument is NULL"); + + json = json_loadb(NULL, 0, 0, &error); + if (json) + fail("json_loadb should return NULL if the first argument is NULL"); + + json = json_loadf(NULL, 0, &error); + if (json) + fail("json_loadf should return NULL if the first argument is NULL"); + + json = json_loadfd(-1, 0, &error); + if (json) + fail("json_loadfd should return NULL if the first argument is < 0"); + + json = json_load_file(NULL, 0, &error); + if (json) + fail("json_load_file should return NULL if the first argument is NULL"); +} + +static void position() { + json_t *json; + size_t flags = JSON_DISABLE_EOF_CHECK; + json_error_t error; + + json = json_loads("{\"foo\": \"bar\"}", 0, &error); + if (error.position != 14) + fail("json_loads returned a wrong position"); + json_decref(json); + + json = json_loads("{\"foo\": \"bar\"} baz quux", flags, &error); + if (error.position != 14) + fail("json_loads returned a wrong position"); + json_decref(json); +} + +static void error_code() { + json_error_t error; + json_t *json = json_loads("[123] garbage", 0, &error); + if (json != NULL) + fail("json_loads returned not NULL"); + if (strlen(error.text) >= JSON_ERROR_TEXT_LENGTH) + fail("error.text longer than expected"); + if (json_error_code(&error) != json_error_end_of_input_expected) + fail("json_loads returned incorrect error code"); + + json = json_loads("{\"foo\": ", 0, &error); + if (json != NULL) + fail("json_loads returned not NULL"); + if (strlen(error.text) >= JSON_ERROR_TEXT_LENGTH) + fail("error.text longer than expected"); + if (json_error_code(&error) != json_error_premature_end_of_input) + fail("json_loads returned incorrect error code"); +} + +static void run_tests() { + file_not_found(); + very_long_file_name(); + reject_duplicates(); + disable_eof_check(); + decode_any(); + decode_int_as_real(); + allow_nul(); + load_wrong_args(); + position(); + error_code(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load_callback.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load_callback.c new file mode 100644 index 000000000..b292fcf42 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_load_callback.c @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2009-2011 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <stdlib.h> +#include <string.h> + +struct my_source { + const char *buf; + size_t off; + size_t cap; +}; + +static const char my_str[] = "[\"A\", {\"B\": \"C\", \"e\": false}, 1, null, \"foo\"]"; + +static size_t greedy_reader(void *buf, size_t buflen, void *arg) { + struct my_source *s = arg; + if (buflen > s->cap - s->off) + buflen = s->cap - s->off; + if (buflen > 0) { + memcpy(buf, s->buf + s->off, buflen); + s->off += buflen; + return buflen; + } else { + return 0; + } +} + +static void run_tests() { + struct my_source s; + json_t *json; + json_error_t error; + + s.off = 0; + s.cap = strlen(my_str); + s.buf = my_str; + + json = json_load_callback(greedy_reader, &s, 0, &error); + + if (!json) + fail("json_load_callback failed on a valid callback"); + json_decref(json); + + s.off = 0; + s.cap = strlen(my_str) - 1; + s.buf = my_str; + + json = json_load_callback(greedy_reader, &s, 0, &error); + if (json) { + json_decref(json); + fail("json_load_callback should have failed on an incomplete stream, " + "but it didn't"); + } + if (strcmp(error.source, "<callback>") != 0) { + fail("json_load_callback returned an invalid error source"); + } + if (strcmp(error.text, "']' expected near end of file") != 0) { + fail("json_load_callback returned an invalid error message for an " + "unclosed top-level array"); + } + + json = json_load_callback(NULL, NULL, 0, &error); + if (json) { + json_decref(json); + fail("json_load_callback should have failed on NULL load callback, but " + "it didn't"); + } + if (strcmp(error.text, "wrong arguments") != 0) { + fail("json_load_callback returned an invalid error message for a NULL " + "load callback"); + } +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_loadb.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_loadb.c new file mode 100644 index 000000000..2cd88fef3 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_loadb.c @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void run_tests() { + json_t *json; + json_error_t error; + const char str[] = "[\"A\", {\"B\": \"C\"}, 1, 2, 3]garbage"; + size_t len = strlen(str) - strlen("garbage"); + + json = json_loadb(str, len, 0, &error); + if (!json) { + fail("json_loadb failed on a valid JSON buffer"); + } + json_decref(json); + + json = json_loadb(str, len - 1, 0, &error); + if (json) { + json_decref(json); + fail("json_loadb should have failed on an incomplete buffer, but it " + "didn't"); + } + if (error.line != 1) { + fail("json_loadb returned an invalid line number on fail"); + } + if (strcmp(error.text, "']' expected near end of file") != 0) { + fail("json_loadb returned an invalid error message for an unclosed " + "top-level array"); + } +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_memory_funcs.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_memory_funcs.c new file mode 100644 index 000000000..4fd616654 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_memory_funcs.c @@ -0,0 +1,115 @@ +#include <jansson.h> +#include <string.h> + +#include "util.h" + +static int malloc_called = 0; +static int free_called = 0; +static size_t malloc_used = 0; + +/* helpers */ +static void create_and_free_complex_object() { + json_t *obj; + + obj = json_pack("{s:i,s:n,s:b,s:b,s:{s:s},s:[i,i,i]}", "foo", 42, "bar", "baz", 1, + "qux", 0, "alice", "bar", "baz", "bob", 9, 8, 7); + + json_decref(obj); +} + +static void create_and_free_object_with_oom() { + int i; + char key[4]; + json_t *obj = json_object(); + + for (i = 0; i < 10; i++) { + snprintf(key, sizeof key, "%d", i); + json_object_set_new(obj, key, json_integer(i)); + } + + json_decref(obj); +} + +static void *my_malloc(size_t size) { + malloc_called = 1; + return malloc(size); +} + +static void my_free(void *ptr) { + free_called = 1; + free(ptr); +} + +static void test_simple() { + json_malloc_t mfunc = NULL; + json_free_t ffunc = NULL; + + json_set_alloc_funcs(my_malloc, my_free); + json_get_alloc_funcs(&mfunc, &ffunc); + create_and_free_complex_object(); + + if (malloc_called != 1 || free_called != 1 || mfunc != my_malloc || ffunc != my_free) + fail("Custom allocation failed"); +} + +static void *oom_malloc(size_t size) { + if (malloc_used + size > 800) + return NULL; + + malloc_used += size; + return malloc(size); +} + +static void oom_free(void *ptr) { + free_called++; + free(ptr); +} + +static void test_oom() { + free_called = 0; + json_set_alloc_funcs(oom_malloc, oom_free); + create_and_free_object_with_oom(); + + if (free_called == 0) + fail("Allocation with OOM failed"); +} + +/* + Test the secure memory functions code given in the API reference + documentation, but by using plain memset instead of + guaranteed_memset(). +*/ + +static void *secure_malloc(size_t size) { + /* Store the memory area size in the beginning of the block */ + void *ptr = malloc(size + 8); + *((size_t *)ptr) = size; + return (char *)ptr + 8; +} + +static void secure_free(void *ptr) { + size_t size; + + ptr = (char *)ptr - 8; + size = *((size_t *)ptr); + + /*guaranteed_*/ memset(ptr, 0, size + 8); + free(ptr); +} + +static void test_secure_funcs(void) { + json_set_alloc_funcs(secure_malloc, secure_free); + create_and_free_complex_object(); +} + +static void test_bad_args(void) { + /* The result of this test is not crashing. */ + json_get_alloc_funcs(NULL, NULL); +} + +static void run_tests() { + test_simple(); + test_secure_funcs(); + test_oom(); + test_bad_args(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_number.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_number.c new file mode 100644 index 000000000..2a22a67d3 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_number.c @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <math.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_t *real = json_real(INFINITY); + if (real != NULL) + fail("could construct a real from Inf"); + + real = json_real(1.0); + if (json_real_set(real, INFINITY) != -1) + fail("could set a real to Inf"); + + if (json_real_value(real) != 1.0) + fail("real value changed unexpectedly"); + + json_decref(real); +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} +#endif // INFINITY + +static void test_bad_args(void) { + json_t *txt = json_string("test"); + + if (json_integer_value(NULL) != 0) + fail("json_integer_value did not return 0 for non-integer"); + if (json_integer_value(txt) != 0) + fail("json_integer_value did not return 0 for non-integer"); + + if (!json_integer_set(NULL, 0)) + fail("json_integer_set did not return error for non-integer"); + if (!json_integer_set(txt, 0)) + fail("json_integer_set did not return error for non-integer"); + + if (json_real_value(NULL) != 0.0) + fail("json_real_value did not return 0.0 for non-real"); + if (json_real_value(txt) != 0.0) + fail("json_real_value did not return 0.0 for non-real"); + + if (!json_real_set(NULL, 0.0)) + fail("json_real_set did not return error for non-real"); + if (!json_real_set(txt, 0.0)) + fail("json_real_set did not return error for non-real"); + + if (json_number_value(NULL) != 0.0) + fail("json_number_value did not return 0.0 for non-numeric"); + if (json_number_value(txt) != 0.0) + fail("json_number_value did not return 0.0 for non-numeric"); + + if (txt->refcount != 1) + fail("unexpected reference count for txt"); + + json_decref(txt); +} + +static void run_tests() { + json_t *integer, *real; + json_int_t i; + double d; + + integer = json_integer(5); + real = json_real(100.1); + + if (!integer) + fail("unable to create integer"); + if (!real) + fail("unable to create real"); + + i = json_integer_value(integer); + if (i != 5) + fail("wrong integer value"); + + d = json_real_value(real); + if (d != 100.1) + fail("wrong real value"); + + d = json_number_value(integer); + if (d != 5.0) + fail("wrong number value"); + d = json_number_value(real); + if (d != 100.1) + fail("wrong number value"); + + json_decref(integer); + json_decref(real); + +#ifdef NAN + real = json_real(NAN); + if (real != NULL) + fail("could construct a real from NaN"); + + real = json_real(1.0); + if (json_real_set(real, NAN) != -1) + fail("could set a real to NaN"); + + if (json_real_value(real) != 1.0) + fail("real value changed unexpectedly"); + + json_decref(real); +#endif + +#ifdef INFINITY + test_inifity(); +#endif + test_bad_args(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_object.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_object.c new file mode 100644 index 000000000..331edf229 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_object.c @@ -0,0 +1,797 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void test_clear() { + json_t *object, *ten; + + object = json_object(); + ten = json_integer(10); + + if (!object) + fail("unable to create object"); + if (!ten) + fail("unable to create integer"); + + if (json_object_set(object, "a", ten) || json_object_set(object, "b", ten) || + json_object_set(object, "c", ten) || json_object_set(object, "d", ten) || + json_object_set(object, "e", ten)) + fail("unable to set value"); + + if (json_object_size(object) != 5) + fail("invalid size"); + + json_object_clear(object); + + if (json_object_size(object) != 0) + fail("invalid size after clear"); + + json_decref(ten); + json_decref(object); +} + +static void test_update() { + json_t *object, *other, *nine, *ten; + + object = json_object(); + other = json_object(); + + nine = json_integer(9); + ten = json_integer(10); + + if (!object || !other) + fail("unable to create object"); + if (!nine || !ten) + fail("unable to create integer"); + + /* update an empty object with an empty object */ + + if (json_object_update(object, other)) + fail("unable to update an empty object with an empty object"); + + if (json_object_size(object) != 0) + fail("invalid size after update"); + + if (json_object_size(other) != 0) + fail("invalid size for updater after update"); + + /* update an empty object with a nonempty object */ + + if (json_object_set(other, "a", ten) || json_object_set(other, "b", ten) || + json_object_set(other, "c", ten) || json_object_set(other, "d", ten) || + json_object_set(other, "e", ten)) + fail("unable to set value"); + + if (json_object_update(object, other)) + fail("unable to update an empty object"); + + if (json_object_size(object) != 5) + fail("invalid size after update"); + + if (json_object_get(object, "a") != ten || json_object_get(object, "b") != ten || + json_object_get(object, "c") != ten || json_object_get(object, "d") != ten || + json_object_get(object, "e") != ten) + fail("update works incorrectly"); + + /* perform the same update again */ + + if (json_object_update(object, other)) + fail("unable to update a non-empty object"); + + if (json_object_size(object) != 5) + fail("invalid size after update"); + + if (json_object_get(object, "a") != ten || json_object_get(object, "b") != ten || + json_object_get(object, "c") != ten || json_object_get(object, "d") != ten || + json_object_get(object, "e") != ten) + fail("update works incorrectly"); + + /* update a nonempty object with a nonempty object with both old + and new keys */ + + if (json_object_clear(other)) + fail("clear failed"); + + if (json_object_set(other, "a", nine) || json_object_set(other, "b", nine) || + json_object_set(other, "f", nine) || json_object_set(other, "g", nine) || + json_object_set(other, "h", nine)) + fail("unable to set value"); + + if (json_object_update(object, other)) + fail("unable to update a nonempty object"); + + if (json_object_size(object) != 8) + fail("invalid size after update"); + + if (json_object_get(object, "a") != nine || json_object_get(object, "b") != nine || + json_object_get(object, "f") != nine || json_object_get(object, "g") != nine || + json_object_get(object, "h") != nine) + fail("update works incorrectly"); + + /* update_new check */ + if (json_object_clear(object)) + fail("clear failed"); + + if (json_object_set(object, "a", ten) || json_object_set(object, "b", ten) || + json_object_set(object, "c", ten) || json_object_set(object, "d", ten) || + json_object_set(object, "e", ten)) + fail("unable to set value"); + + if (json_object_update_new( + object, json_pack("{s:O, s:O, s:O}", "b", nine, "f", nine, "g", nine))) + fail("unable to update_new a nonempty object"); + + if (json_object_size(object) != 7) + fail("invalid size after update_new"); + + if (json_object_get(object, "a") != ten || json_object_get(object, "b") != nine || + json_object_get(object, "c") != ten || json_object_get(object, "d") != ten || + json_object_get(object, "e") != ten || json_object_get(object, "f") != nine || + json_object_get(object, "g") != nine) + fail("update_new works incorrectly"); + + json_decref(nine); + json_decref(ten); + json_decref(other); + json_decref(object); +} + +static void test_set_many_keys() { + json_t *object, *value; + const char *keys = "abcdefghijklmnopqrstuvwxyz"; + char buf[2]; + size_t i; + + object = json_object(); + if (!object) + fail("unable to create object"); + + value = json_string("a"); + if (!value) + fail("unable to create string"); + + buf[1] = '\0'; + for (i = 0; i < strlen(keys); i++) { + buf[0] = keys[i]; + if (json_object_set(object, buf, value)) + fail("unable to set object key"); + } + + json_decref(object); + json_decref(value); +} + +static void test_conditional_updates() { + json_t *object, *other; + + object = json_pack("{sisi}", "foo", 1, "bar", 2); + other = json_pack("{sisi}", "foo", 3, "baz", 4); + + if (json_object_update_existing(object, other)) + fail("json_object_update_existing failed"); + + if (json_object_size(object) != 2) + fail("json_object_update_existing added new items"); + + if (json_integer_value(json_object_get(object, "foo")) != 3) + fail("json_object_update_existing failed to update existing key"); + + if (json_integer_value(json_object_get(object, "bar")) != 2) + fail("json_object_update_existing updated wrong key"); + + json_decref(object); + + /* json_object_update_existing_new check */ + object = json_pack("{sisi}", "foo", 1, "bar", 2); + + if (json_object_update_existing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4))) + fail("json_object_update_existing_new failed"); + + if (json_object_size(object) != 2) + fail("json_object_update_existing_new added new items"); + + if (json_integer_value(json_object_get(object, "foo")) != 3) + fail("json_object_update_existing_new failed to update existing key"); + + if (json_integer_value(json_object_get(object, "bar")) != 2) + fail("json_object_update_existing_new updated wrong key"); + + json_decref(object); + + object = json_pack("{sisi}", "foo", 1, "bar", 2); + + if (json_object_update_missing(object, other)) + fail("json_object_update_missing failed"); + + if (json_object_size(object) != 3) + fail("json_object_update_missing didn't add new items"); + + if (json_integer_value(json_object_get(object, "foo")) != 1) + fail("json_object_update_missing updated existing key"); + + if (json_integer_value(json_object_get(object, "bar")) != 2) + fail("json_object_update_missing updated wrong key"); + + if (json_integer_value(json_object_get(object, "baz")) != 4) + fail("json_object_update_missing didn't add new items"); + + json_decref(object); + + /* json_object_update_missing_new check */ + object = json_pack("{sisi}", "foo", 1, "bar", 2); + + if (json_object_update_missing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4))) + fail("json_object_update_missing_new failed"); + + if (json_object_size(object) != 3) + fail("json_object_update_missing_new didn't add new items"); + + if (json_integer_value(json_object_get(object, "foo")) != 1) + fail("json_object_update_missing_new updated existing key"); + + if (json_integer_value(json_object_get(object, "bar")) != 2) + fail("json_object_update_missing_new updated wrong key"); + + if (json_integer_value(json_object_get(object, "baz")) != 4) + fail("json_object_update_missing_new didn't add new items"); + + json_decref(object); + json_decref(other); +} + +static void test_recursive_updates() { + json_t *invalid, *object, *other, *barBefore, *barAfter; + + invalid = json_integer(42); + + object = json_pack("{sis{si}}", "foo", 1, "bar", "baz", 2); + other = json_pack("{sisisi}", "foo", 3, "bar", 4, "baz", 5); + + if (!json_object_update_recursive(invalid, other)) + fail("json_object_update_recursive accepted non-object argument"); + + json_decref(invalid); + + if (json_object_update_recursive(object, other)) + fail("json_object_update_recursive failed"); + + if (json_object_size(object) != 3) + fail("invalid size after update"); + + if (json_integer_value(json_object_get(object, "foo")) != 3) + fail("json_object_update_recursive failed to update existing key"); + + if (json_integer_value(json_object_get(object, "bar")) != 4) + fail("json_object_update_recursive failed to overwrite object"); + + if (json_integer_value(json_object_get(object, "baz")) != 5) + fail("json_object_update_recursive didn't add new item"); + + json_decref(object); + json_decref(other); + + object = json_pack("{sis{si}}", "foo", 1, "bar", "baz", 2); + other = json_pack("{s{si}}", "bar", "baz", 3); + barBefore = json_object_get(object, "bar"); + + if (!barBefore) + fail("can't get bar object before json_object_update_recursive"); + + if (json_object_update_recursive(object, other)) + fail("json_object_update_recursive failed"); + + if (json_object_size(object) != 2) + fail("invalid size after update"); + + if (!json_object_get(object, "foo")) + fail("json_object_update_recursive removed existing key"); + + if (json_integer_value(json_object_get(json_object_get(object, "bar"), "baz")) != 3) + fail("json_object_update_recursive failed to update nested value"); + + barAfter = json_object_get(object, "bar"); + if (!barAfter) + fail("can't get bar object after json_object_update_recursive"); + + if (barBefore != barAfter) + fail("bar object reference changed after json_object_update_recursive"); + + json_decref(object); + json_decref(other); + + /* check circular reference */ + object = json_pack("{s{s{s{si}}}}", "foo", "bar", "baz", "xxx", 2); + other = json_pack("{s{s{si}}}", "foo", "bar", "baz", 2); + json_object_set(json_object_get(json_object_get(other, "foo"), "bar"), "baz", + json_object_get(other, "foo")); + + if (!json_object_update_recursive(object, other)) + fail("json_object_update_recursive update a circular reference!"); + + json_object_set_new(json_object_get(json_object_get(other, "foo"), "bar"), "baz", + json_integer(1)); + + if (json_object_update_recursive(object, other)) + fail("json_object_update_recursive failed!"); + + json_decref(object); + json_decref(other); +} + +static void test_circular() { + json_t *object1, *object2; + + object1 = json_object(); + object2 = json_object(); + if (!object1 || !object2) + fail("unable to create object"); + + /* the simple case is checked */ + if (json_object_set(object1, "a", object1) == 0) + fail("able to set self"); + + /* create circular references */ + if (json_object_set(object1, "a", object2) || json_object_set(object2, "a", object1)) + fail("unable to set value"); + + /* circularity is detected when dumping */ + if (json_dumps(object1, 0) != NULL) + fail("able to dump circulars"); + + /* decref twice to deal with the circular references */ + json_decref(object1); + json_decref(object2); + json_decref(object1); +} + +static void test_set_nocheck() { + json_t *object, *string; + + object = json_object(); + string = json_string("bar"); + + if (!object) + fail("unable to create object"); + if (!string) + fail("unable to create string"); + + if (json_object_set_nocheck(object, "foo", string)) + fail("json_object_set_nocheck failed"); + if (json_object_get(object, "foo") != string) + fail("json_object_get after json_object_set_nocheck failed"); + + /* invalid UTF-8 in key */ + if (json_object_set_nocheck(object, "a\xefz", string)) + fail("json_object_set_nocheck failed for invalid UTF-8"); + if (json_object_get(object, "a\xefz") != string) + fail("json_object_get after json_object_set_nocheck failed"); + + if (json_object_set_new_nocheck(object, "bax", json_integer(123))) + fail("json_object_set_new_nocheck failed"); + if (json_integer_value(json_object_get(object, "bax")) != 123) + fail("json_object_get after json_object_set_new_nocheck failed"); + + /* invalid UTF-8 in key */ + if (json_object_set_new_nocheck(object, "asdf\xfe", json_integer(321))) + fail("json_object_set_new_nocheck failed for invalid UTF-8"); + if (json_integer_value(json_object_get(object, "asdf\xfe")) != 321) + fail("json_object_get after json_object_set_new_nocheck failed"); + + json_decref(string); + json_decref(object); +} + +static void test_iterators() { + json_t *object, *foo, *bar, *baz; + void *iter; + + if (json_object_iter(NULL)) + fail("able to iterate over NULL"); + + if (json_object_iter_next(NULL, NULL)) + fail("able to increment an iterator on a NULL object"); + + object = json_object(); + foo = json_string("foo"); + bar = json_string("bar"); + baz = json_string("baz"); + if (!object || !foo || !bar || !baz) + fail("unable to create values"); + + if (json_object_iter_next(object, NULL)) + fail("able to increment a NULL iterator"); + + if (json_object_set(object, "a", foo) || json_object_set(object, "b", bar) || + json_object_set(object, "c", baz)) + fail("unable to populate object"); + + iter = json_object_iter(object); + if (!iter) + fail("unable to get iterator"); + if (strcmp(json_object_iter_key(iter), "a") != 0) + fail("iterating doesn't yield keys in order"); + if (json_object_iter_value(iter) != foo) + fail("iterating doesn't yield values in order"); + + iter = json_object_iter_next(object, iter); + if (!iter) + fail("unable to increment iterator"); + if (strcmp(json_object_iter_key(iter), "b") != 0) + fail("iterating doesn't yield keys in order"); + if (json_object_iter_value(iter) != bar) + fail("iterating doesn't yield values in order"); + + iter = json_object_iter_next(object, iter); + if (!iter) + fail("unable to increment iterator"); + if (strcmp(json_object_iter_key(iter), "c") != 0) + fail("iterating doesn't yield keys in order"); + if (json_object_iter_value(iter) != baz) + fail("iterating doesn't yield values in order"); + + if (json_object_iter_next(object, iter) != NULL) + fail("able to iterate over the end"); + + if (json_object_iter_at(object, "foo")) + fail("json_object_iter_at() succeeds for non-existent key"); + + iter = json_object_iter_at(object, "b"); + if (!iter) + fail("json_object_iter_at() fails for an existing key"); + + if (strcmp(json_object_iter_key(iter), "b")) + fail("iterating failed: wrong key"); + if (json_object_iter_value(iter) != bar) + fail("iterating failed: wrong value"); + + if (json_object_iter_set(object, iter, baz)) + fail("unable to set value at iterator"); + + if (strcmp(json_object_iter_key(iter), "b")) + fail("json_object_iter_key() fails after json_object_iter_set()"); + if (json_object_iter_value(iter) != baz) + fail("json_object_iter_value() fails after json_object_iter_set()"); + if (json_object_get(object, "b") != baz) + fail("json_object_get() fails after json_object_iter_set()"); + + json_decref(object); + json_decref(foo); + json_decref(bar); + json_decref(baz); +} + +static void test_misc() { + json_t *object, *string, *other_string, *value; + + object = json_object(); + string = json_string("test"); + other_string = json_string("other"); + + if (!object) + fail("unable to create object"); + if (!string || !other_string) + fail("unable to create string"); + + if (json_object_get(object, "a")) + fail("value for nonexisting key"); + + if (json_object_set(object, "a", string)) + fail("unable to set value"); + + if (!json_object_set(object, NULL, string)) + fail("able to set NULL key"); + + if (json_object_del(object, "a")) + fail("unable to del the only key"); + + if (json_object_set(object, "a", string)) + fail("unable to set value"); + + if (!json_object_set(object, "a", NULL)) + fail("able to set NULL value"); + + /* invalid UTF-8 in key */ + if (!json_object_set(object, "a\xefz", string)) + fail("able to set invalid unicode key"); + + value = json_object_get(object, "a"); + if (!value) + fail("no value for existing key"); + if (value != string) + fail("got different value than what was added"); + + /* "a", "lp" and "px" collide in a five-bucket hashtable */ + if (json_object_set(object, "b", string) || json_object_set(object, "lp", string) || + json_object_set(object, "px", string)) + fail("unable to set value"); + + value = json_object_get(object, "a"); + if (!value) + fail("no value for existing key"); + if (value != string) + fail("got different value than what was added"); + + if (json_object_set(object, "a", other_string)) + fail("unable to replace an existing key"); + + value = json_object_get(object, "a"); + if (!value) + fail("no value for existing key"); + if (value != other_string) + fail("got different value than what was set"); + + if (!json_object_del(object, "nonexisting")) + fail("able to delete a nonexisting key"); + + if (json_object_del(object, "px")) + fail("unable to delete an existing key"); + + if (json_object_del(object, "a")) + fail("unable to delete an existing key"); + + if (json_object_del(object, "lp")) + fail("unable to delete an existing key"); + + /* add many keys to initiate rehashing */ + + if (json_object_set(object, "a", string)) + fail("unable to set value"); + + if (json_object_set(object, "lp", string)) + fail("unable to set value"); + + if (json_object_set(object, "px", string)) + fail("unable to set value"); + + if (json_object_set(object, "c", string)) + fail("unable to set value"); + + if (json_object_set(object, "d", string)) + fail("unable to set value"); + + if (json_object_set(object, "e", string)) + fail("unable to set value"); + + if (json_object_set_new(object, "foo", json_integer(123))) + fail("unable to set new value"); + + value = json_object_get(object, "foo"); + if (!json_is_integer(value) || json_integer_value(value) != 123) + fail("json_object_set_new works incorrectly"); + + if (!json_object_set_new(object, NULL, json_integer(432))) + fail("able to set_new NULL key"); + + if (!json_object_set_new(object, "foo", NULL)) + fail("able to set_new NULL value"); + + json_decref(string); + json_decref(other_string); + json_decref(object); +} + +static void test_preserve_order() { + json_t *object; + char *result; + + const char *expected = "{\"foobar\": 1, \"bazquux\": 6, \"lorem ipsum\": " + "3, \"sit amet\": 5, \"helicopter\": 7}"; + + object = json_object(); + + json_object_set_new(object, "foobar", json_integer(1)); + json_object_set_new(object, "bazquux", json_integer(2)); + json_object_set_new(object, "lorem ipsum", json_integer(3)); + json_object_set_new(object, "dolor", json_integer(4)); + json_object_set_new(object, "sit amet", json_integer(5)); + + /* changing a value should preserve the order */ + json_object_set_new(object, "bazquux", json_integer(6)); + + /* deletion shouldn't change the order of others */ + json_object_del(object, "dolor"); + + /* add a new item just to make sure */ + json_object_set_new(object, "helicopter", json_integer(7)); + + result = json_dumps(object, JSON_PRESERVE_ORDER); + + if (strcmp(expected, result) != 0) { + fprintf(stderr, "%s != %s", expected, result); + fail("JSON_PRESERVE_ORDER doesn't work"); + } + + free(result); + json_decref(object); +} + +static void test_object_foreach() { + const char *key; + json_t *object1, *object2, *value; + + object1 = json_pack("{sisisi}", "foo", 1, "bar", 2, "baz", 3); + object2 = json_object(); + + json_object_foreach(object1, key, value) json_object_set(object2, key, value); + + if (!json_equal(object1, object2)) + fail("json_object_foreach failed to iterate all key-value pairs"); + + json_decref(object1); + json_decref(object2); +} + +static void test_object_foreach_safe() { + const char *key; + void *tmp; + json_t *object, *value; + + object = json_pack("{sisisi}", "foo", 1, "bar", 2, "baz", 3); + + json_object_foreach_safe(object, tmp, key, value) { json_object_del(object, key); } + + if (json_object_size(object) != 0) + fail("json_object_foreach_safe failed to iterate all key-value pairs"); + + json_decref(object); +} + +static void test_bad_args(void) { + json_t *obj = json_object(); + json_t *num = json_integer(1); + void *iter; + + if (!obj || !num) + fail("failed to allocate test objects"); + + if (json_object_set(obj, "testkey", json_null())) + fail("failed to set testkey on object"); + + iter = json_object_iter(obj); + if (!iter) + fail("failed to retrieve test iterator"); + + if (json_object_size(NULL) != 0) + fail("json_object_size with non-object argument returned non-zero"); + if (json_object_size(num) != 0) + fail("json_object_size with non-object argument returned non-zero"); + + if (json_object_get(NULL, "test") != NULL) + fail("json_object_get with non-object argument returned non-NULL"); + if (json_object_get(num, "test") != NULL) + fail("json_object_get with non-object argument returned non-NULL"); + if (json_object_get(obj, NULL) != NULL) + fail("json_object_get with NULL key returned non-NULL"); + + if (!json_object_set_new_nocheck(NULL, "test", json_null())) + fail("json_object_set_new_nocheck with non-object argument did not " + "return error"); + if (!json_object_set_new_nocheck(num, "test", json_null())) + fail("json_object_set_new_nocheck with non-object argument did not " + "return error"); + if (!json_object_set_new_nocheck(obj, "test", json_incref(obj))) + fail("json_object_set_new_nocheck with object == value did not return " + "error"); + if (!json_object_set_new_nocheck(obj, NULL, json_object())) + fail("json_object_set_new_nocheck with NULL key did not return error"); + + if (!json_object_del(NULL, "test")) + fail("json_object_del with non-object argument did not return error"); + if (!json_object_del(num, "test")) + fail("json_object_del with non-object argument did not return error"); + if (!json_object_del(obj, NULL)) + fail("json_object_del with NULL key did not return error"); + + if (!json_object_clear(NULL)) + fail("json_object_clear with non-object argument did not return error"); + if (!json_object_clear(num)) + fail("json_object_clear with non-object argument did not return error"); + + if (!json_object_update(NULL, obj)) + fail("json_object_update with non-object first argument did not return " + "error"); + if (!json_object_update(num, obj)) + fail("json_object_update with non-object first argument did not return " + "error"); + if (!json_object_update(obj, NULL)) + fail("json_object_update with non-object second argument did not " + "return error"); + if (!json_object_update(obj, num)) + fail("json_object_update with non-object second argument did not " + "return error"); + + if (!json_object_update_existing(NULL, obj)) + fail("json_object_update_existing with non-object first argument did " + "not return error"); + if (!json_object_update_existing(num, obj)) + fail("json_object_update_existing with non-object first argument did " + "not return error"); + if (!json_object_update_existing(obj, NULL)) + fail("json_object_update_existing with non-object second argument did " + "not return error"); + if (!json_object_update_existing(obj, num)) + fail("json_object_update_existing with non-object second argument did " + "not return error"); + + if (!json_object_update_missing(NULL, obj)) + fail("json_object_update_missing with non-object first argument did " + "not return error"); + if (!json_object_update_missing(num, obj)) + fail("json_object_update_missing with non-object first argument did " + "not return error"); + if (!json_object_update_missing(obj, NULL)) + fail("json_object_update_missing with non-object second argument did " + "not return error"); + if (!json_object_update_missing(obj, num)) + fail("json_object_update_missing with non-object second argument did " + "not return error"); + + if (json_object_iter(NULL) != NULL) + fail("json_object_iter with non-object argument returned non-NULL"); + if (json_object_iter(num) != NULL) + fail("json_object_iter with non-object argument returned non-NULL"); + + if (json_object_iter_at(NULL, "test") != NULL) + fail("json_object_iter_at with non-object argument returned non-NULL"); + if (json_object_iter_at(num, "test") != NULL) + fail("json_object_iter_at with non-object argument returned non-NULL"); + if (json_object_iter_at(obj, NULL) != NULL) + fail("json_object_iter_at with NULL iter returned non-NULL"); + + if (json_object_iter_next(obj, NULL) != NULL) + fail("json_object_iter_next with NULL iter returned non-NULL"); + if (json_object_iter_next(num, iter) != NULL) + fail("json_object_iter_next with non-object argument returned non-NULL"); + + if (json_object_iter_key(NULL) != NULL) + fail("json_object_iter_key with NULL iter returned non-NULL"); + + if (json_object_key_to_iter(NULL) != NULL) + fail("json_object_key_to_iter with NULL iter returned non-NULL"); + + if (json_object_iter_value(NULL) != NULL) + fail("json_object_iter_value with NULL iter returned non-NULL"); + + if (!json_object_iter_set_new(NULL, iter, json_incref(num))) + fail("json_object_iter_set_new with non-object argument did not return " + "error"); + if (!json_object_iter_set_new(num, iter, json_incref(num))) + fail("json_object_iter_set_new with non-object argument did not return " + "error"); + if (!json_object_iter_set_new(obj, NULL, json_incref(num))) + fail("json_object_iter_set_new with NULL iter did not return error"); + if (!json_object_iter_set_new(obj, iter, NULL)) + fail("json_object_iter_set_new with NULL value did not return error"); + + if (obj->refcount != 1) + fail("unexpected reference count for obj"); + + if (num->refcount != 1) + fail("unexpected reference count for num"); + + json_decref(obj); + json_decref(num); +} + +static void run_tests() { + test_misc(); + test_clear(); + test_update(); + test_set_many_keys(); + test_conditional_updates(); + test_recursive_updates(); + test_circular(); + test_set_nocheck(); + test_iterators(); + test_preserve_order(); + test_object_foreach(); + test_object_foreach_safe(); + test_bad_args(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_pack.c new file mode 100644 index 000000000..865f60b68 --- /dev/null +++ b/src/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); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_simple.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_simple.c new file mode 100644 index 000000000..7a3f6b7bf --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_simple.c @@ -0,0 +1,287 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void test_bad_args(void) { + json_t *num = json_integer(1); + json_t *txt = json_string("test"); + + if (!num || !txt) + fail("failed to allocate test objects"); + + if (json_string_nocheck(NULL) != NULL) + fail("json_string_nocheck with NULL argument did not return NULL"); + if (json_stringn_nocheck(NULL, 0) != NULL) + fail("json_stringn_nocheck with NULL argument did not return NULL"); + if (json_string(NULL) != NULL) + fail("json_string with NULL argument did not return NULL"); + if (json_stringn(NULL, 0) != NULL) + fail("json_stringn with NULL argument did not return NULL"); + + if (json_string_length(NULL) != 0) + fail("json_string_length with non-string argument did not return 0"); + if (json_string_length(num) != 0) + fail("json_string_length with non-string argument did not return 0"); + + if (json_string_value(NULL) != NULL) + fail("json_string_value with non-string argument did not return NULL"); + if (json_string_value(num) != NULL) + fail("json_string_value with non-string argument did not return NULL"); + + if (!json_string_setn_nocheck(NULL, "", 0)) + fail("json_string_setn with non-string argument did not return error"); + if (!json_string_setn_nocheck(num, "", 0)) + fail("json_string_setn with non-string argument did not return error"); + if (!json_string_setn_nocheck(txt, NULL, 0)) + fail("json_string_setn_nocheck with NULL value did not return error"); + + if (!json_string_set_nocheck(txt, NULL)) + fail("json_string_set_nocheck with NULL value did not return error"); + if (!json_string_set(txt, NULL)) + fail("json_string_set with NULL value did not return error"); + if (!json_string_setn(txt, NULL, 0)) + fail("json_string_setn with NULL value did not return error"); + + if (num->refcount != 1) + fail("unexpected reference count for num"); + if (txt->refcount != 1) + fail("unexpected reference count for txt"); + + json_decref(num); + json_decref(txt); +} + +/* Call the simple functions not covered by other tests of the public API */ +static void run_tests() { + json_t *value; + + value = json_boolean(1); + if (!json_is_true(value)) + fail("json_boolean(1) failed"); + json_decref(value); + + value = json_boolean(-123); + if (!json_is_true(value)) + fail("json_boolean(-123) failed"); + json_decref(value); + + value = json_boolean(0); + if (!json_is_false(value)) + fail("json_boolean(0) failed"); + if (json_boolean_value(value) != 0) + fail("json_boolean_value failed"); + json_decref(value); + + value = json_integer(1); + if (json_typeof(value) != JSON_INTEGER) + fail("json_typeof failed"); + + if (json_is_object(value)) + fail("json_is_object failed"); + + if (json_is_array(value)) + fail("json_is_array failed"); + + if (json_is_string(value)) + fail("json_is_string failed"); + + if (!json_is_integer(value)) + fail("json_is_integer failed"); + + if (json_is_real(value)) + fail("json_is_real failed"); + + if (!json_is_number(value)) + fail("json_is_number failed"); + + if (json_is_true(value)) + fail("json_is_true failed"); + + if (json_is_false(value)) + fail("json_is_false failed"); + + if (json_is_boolean(value)) + fail("json_is_boolean failed"); + + if (json_is_null(value)) + fail("json_is_null failed"); + + json_decref(value); + + value = json_string("foo"); + if (!value) + fail("json_string failed"); + if (strcmp(json_string_value(value), "foo")) + fail("invalid string value"); + if (json_string_length(value) != 3) + fail("invalid string length"); + + if (json_string_set(value, "barr")) + fail("json_string_set failed"); + if (strcmp(json_string_value(value), "barr")) + fail("invalid string value"); + if (json_string_length(value) != 4) + fail("invalid string length"); + + if (json_string_setn(value, "hi\0ho", 5)) + fail("json_string_set failed"); + if (memcmp(json_string_value(value), "hi\0ho\0", 6)) + fail("invalid string value"); + if (json_string_length(value) != 5) + fail("invalid string length"); + + json_decref(value); + + value = json_string(NULL); + if (value) + fail("json_string(NULL) failed"); + + /* invalid UTF-8 */ + value = json_string("a\xefz"); + if (value) + fail("json_string(<invalid utf-8>) failed"); + + value = json_string_nocheck("foo"); + if (!value) + fail("json_string_nocheck failed"); + if (strcmp(json_string_value(value), "foo")) + fail("invalid string value"); + if (json_string_length(value) != 3) + fail("invalid string length"); + + if (json_string_set_nocheck(value, "barr")) + fail("json_string_set_nocheck failed"); + if (strcmp(json_string_value(value), "barr")) + fail("invalid string value"); + if (json_string_length(value) != 4) + fail("invalid string length"); + + if (json_string_setn_nocheck(value, "hi\0ho", 5)) + fail("json_string_set failed"); + if (memcmp(json_string_value(value), "hi\0ho\0", 6)) + fail("invalid string value"); + if (json_string_length(value) != 5) + fail("invalid string length"); + + json_decref(value); + + /* invalid UTF-8 */ + value = json_string_nocheck("qu\xff"); + if (!value) + fail("json_string_nocheck failed"); + if (strcmp(json_string_value(value), "qu\xff")) + fail("invalid string value"); + if (json_string_length(value) != 3) + fail("invalid string length"); + + if (json_string_set_nocheck(value, "\xfd\xfe\xff")) + fail("json_string_set_nocheck failed"); + if (strcmp(json_string_value(value), "\xfd\xfe\xff")) + fail("invalid string value"); + if (json_string_length(value) != 3) + fail("invalid string length"); + + json_decref(value); + + value = json_integer(123); + if (!value) + fail("json_integer failed"); + if (json_integer_value(value) != 123) + fail("invalid integer value"); + if (json_number_value(value) != 123.0) + fail("invalid number value"); + + if (json_integer_set(value, 321)) + fail("json_integer_set failed"); + if (json_integer_value(value) != 321) + fail("invalid integer value"); + if (json_number_value(value) != 321.0) + fail("invalid number value"); + + json_decref(value); + + value = json_real(123.123); + if (!value) + fail("json_real failed"); + if (json_real_value(value) != 123.123) + fail("invalid integer value"); + if (json_number_value(value) != 123.123) + fail("invalid number value"); + + if (json_real_set(value, 321.321)) + fail("json_real_set failed"); + if (json_real_value(value) != 321.321) + fail("invalid real value"); + if (json_number_value(value) != 321.321) + fail("invalid number value"); + + json_decref(value); + + value = json_true(); + if (!value) + fail("json_true failed"); + json_decref(value); + + value = json_false(); + if (!value) + fail("json_false failed"); + json_decref(value); + + value = json_null(); + if (!value) + fail("json_null failed"); + json_decref(value); + + /* Test reference counting on singletons (true, false, null) */ + value = json_true(); + if (value->refcount != (size_t)-1) + fail("refcounting true works incorrectly"); + json_decref(value); + if (value->refcount != (size_t)-1) + fail("refcounting true works incorrectly"); + json_incref(value); + if (value->refcount != (size_t)-1) + fail("refcounting true works incorrectly"); + + value = json_false(); + if (value->refcount != (size_t)-1) + fail("refcounting false works incorrectly"); + json_decref(value); + if (value->refcount != (size_t)-1) + fail("refcounting false works incorrectly"); + json_incref(value); + if (value->refcount != (size_t)-1) + fail("refcounting false works incorrectly"); + + value = json_null(); + if (value->refcount != (size_t)-1) + fail("refcounting null works incorrectly"); + json_decref(value); + if (value->refcount != (size_t)-1) + fail("refcounting null works incorrectly"); + json_incref(value); + if (value->refcount != (size_t)-1) + fail("refcounting null works incorrectly"); + +#ifdef json_auto_t + value = json_string("foo"); + { + json_auto_t *test = json_incref(value); + /* Use test so GCC doesn't complain it is unused. */ + if (!json_is_string(test)) + fail("value type check failed"); + } + if (value->refcount != 1) + fail("automatic decrement failed"); + json_decref(value); +#endif + + test_bad_args(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_sprintf.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_sprintf.c new file mode 100644 index 000000000..60a0b601d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_sprintf.c @@ -0,0 +1,29 @@ +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void test_sprintf() { + json_t *s = json_sprintf("foo bar %d", 42); + if (!s) + fail("json_sprintf returned NULL"); + if (!json_is_string(s)) + fail("json_sprintf didn't return a JSON string"); + if (strcmp(json_string_value(s), "foo bar 42")) + fail("json_sprintf generated an unexpected string"); + + json_decref(s); + + s = json_sprintf("%s", ""); + if (!s) + fail("json_sprintf returned NULL"); + if (!json_is_string(s)) + fail("json_sprintf didn't return a JSON string"); + if (json_string_length(s) != 0) + fail("string is not empty"); + json_decref(s); + + if (json_sprintf("%s", "\xff\xff")) + fail("json_sprintf unexpected success with invalid UTF"); +} + +static void run_tests() { test_sprintf(); } diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_unpack.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_unpack.c new file mode 100644 index 000000000..139ec6f7b --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_unpack.c @@ -0,0 +1,431 @@ +/* + * 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. + */ + +#include "util.h" +#include <jansson.h> +#include <stdio.h> +#include <string.h> + +static void run_tests() { + json_t *j, *j2; + int i1, i2, i3; + json_int_t I1; + int rv; + size_t z; + double f; + char *s; + + json_error_t error; + + /* + * Simple, valid json_pack cases + */ + + /* true */ + rv = json_unpack(json_true(), "b", &i1); + if (rv || !i1) + fail("json_unpack boolean failed"); + + /* false */ + rv = json_unpack(json_false(), "b", &i1); + if (rv || i1) + fail("json_unpack boolean failed"); + + /* null */ + if (json_unpack(json_null(), "n")) + fail("json_unpack null failed"); + + /* integer */ + j = json_integer(42); + rv = json_unpack(j, "i", &i1); + if (rv || i1 != 42) + fail("json_unpack integer failed"); + json_decref(j); + + /* json_int_t */ + j = json_integer(5555555); + rv = json_unpack(j, "I", &I1); + if (rv || I1 != 5555555) + fail("json_unpack json_int_t failed"); + json_decref(j); + + /* real */ + j = json_real(1.7); + rv = json_unpack(j, "f", &f); + if (rv || f != 1.7) + fail("json_unpack real failed"); + json_decref(j); + + /* number */ + j = json_integer(12345); + rv = json_unpack(j, "F", &f); + if (rv || f != 12345.0) + fail("json_unpack (real or) integer failed"); + json_decref(j); + + j = json_real(1.7); + rv = json_unpack(j, "F", &f); + if (rv || f != 1.7) + fail("json_unpack real (or integer) failed"); + json_decref(j); + + /* string */ + j = json_string("foo"); + rv = json_unpack(j, "s", &s); + if (rv || strcmp(s, "foo")) + fail("json_unpack string failed"); + json_decref(j); + + /* string with length (size_t) */ + j = json_string("foo"); + rv = json_unpack(j, "s%", &s, &z); + if (rv || strcmp(s, "foo") || z != 3) + fail("json_unpack string with length (size_t) failed"); + json_decref(j); + + /* empty object */ + j = json_object(); + if (json_unpack(j, "{}")) + fail("json_unpack empty object failed"); + json_decref(j); + + /* empty list */ + j = json_array(); + if (json_unpack(j, "[]")) + fail("json_unpack empty list failed"); + json_decref(j); + + /* non-incref'd object */ + j = json_object(); + rv = json_unpack(j, "o", &j2); + if (rv || j2 != j || j->refcount != 1) + fail("json_unpack object failed"); + json_decref(j); + + /* incref'd object */ + j = json_object(); + rv = json_unpack(j, "O", &j2); + if (rv || j2 != j || j->refcount != 2) + fail("json_unpack object failed"); + json_decref(j); + json_decref(j); + + /* simple object */ + j = json_pack("{s:i}", "foo", 42); + rv = json_unpack(j, "{s:i}", "foo", &i1); + if (rv || i1 != 42) + fail("json_unpack simple object failed"); + json_decref(j); + + /* simple array */ + j = json_pack("[iii]", 1, 2, 3); + rv = json_unpack(j, "[i,i,i]", &i1, &i2, &i3); + if (rv || i1 != 1 || i2 != 2 || i3 != 3) + fail("json_unpack simple array failed"); + json_decref(j); + + /* object with many items & strict checking */ + j = json_pack("{s:i, s:i, s:i}", "a", 1, "b", 2, "c", 3); + rv = json_unpack(j, "{s:i, s:i, s:i}", "a", &i1, "b", &i2, "c", &i3); + if (rv || i1 != 1 || i2 != 2 || i3 != 3) + fail("json_unpack object with many items failed"); + json_decref(j); + + /* + * Invalid cases + */ + + j = json_integer(42); + if (!json_unpack_ex(j, &error, 0, "z")) + fail("json_unpack succeeded with invalid format character"); + check_error(json_error_invalid_format, "Unexpected format character 'z'", "<format>", + 1, 1, 1); + + if (!json_unpack_ex(NULL, &error, 0, "[i]")) + fail("json_unpack succeeded with NULL root"); + check_error(json_error_null_value, "NULL root value", "<root>", -1, -1, 0); + json_decref(j); + + /* mismatched open/close array/object */ + j = json_pack("[]"); + if (!json_unpack_ex(j, &error, 0, "[}")) + fail("json_unpack failed to catch mismatched ']'"); + check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", + 1, 2, 2); + json_decref(j); + + j = json_pack("{}"); + if (!json_unpack_ex(j, &error, 0, "{]")) + fail("json_unpack failed to catch mismatched '}'"); + check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, + 2, 2); + json_decref(j); + + /* missing close array */ + j = json_pack("[]"); + if (!json_unpack_ex(j, &error, 0, "[")) + fail("json_unpack failed to catch missing ']'"); + check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", + 1, 2, 2); + json_decref(j); + + /* missing close object */ + j = json_pack("{}"); + if (!json_unpack_ex(j, &error, 0, "{")) + fail("json_unpack failed to catch missing '}'"); + check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", + 1, 2, 2); + json_decref(j); + + /* garbage after format string */ + j = json_pack("[i]", 42); + if (!json_unpack_ex(j, &error, 0, "[i]a", &i1)) + fail("json_unpack failed to catch garbage after format string"); + check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, + 4, 4); + json_decref(j); + + j = json_integer(12345); + if (!json_unpack_ex(j, &error, 0, "ia", &i1)) + fail("json_unpack failed to catch garbage after format string"); + check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, + 2, 2); + json_decref(j); + + /* NULL format string */ + j = json_pack("[]"); + if (!json_unpack_ex(j, &error, 0, NULL)) + fail("json_unpack failed to catch null format string"); + check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", + -1, -1, 0); + json_decref(j); + + /* NULL string pointer */ + j = json_string("foobie"); + if (!json_unpack_ex(j, &error, 0, "s", NULL)) + fail("json_unpack failed to catch null string pointer"); + check_error(json_error_null_value, "NULL string argument", "<args>", 1, 1, 1); + json_decref(j); + + /* invalid types */ + j = json_integer(42); + j2 = json_string("foo"); + if (!json_unpack_ex(j, &error, 0, "s")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected string, got integer", "<validation>", 1, + 1, 1); + + if (!json_unpack_ex(j, &error, 0, "n")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected null, got integer", "<validation>", 1, 1, + 1); + + if (!json_unpack_ex(j, &error, 0, "b")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected true or false, got integer", + "<validation>", 1, 1, 1); + + if (!json_unpack_ex(j2, &error, 0, "i")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, + 1, 1); + + if (!json_unpack_ex(j2, &error, 0, "I")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, + 1, 1); + + if (!json_unpack_ex(j, &error, 0, "f")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected real, got integer", "<validation>", 1, 1, + 1); + + if (!json_unpack_ex(j2, &error, 0, "F")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected real or integer, got string", + "<validation>", 1, 1, 1); + + if (!json_unpack_ex(j, &error, 0, "[i]")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected array, got integer", "<validation>", 1, + 1, 1); + + if (!json_unpack_ex(j, &error, 0, "{si}", "foo")) + fail("json_unpack failed to catch invalid type"); + check_error(json_error_wrong_type, "Expected object, got integer", "<validation>", 1, + 1, 1); + + json_decref(j); + json_decref(j2); + + /* Array index out of range */ + j = json_pack("[i]", 1); + if (!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2)) + fail("json_unpack failed to catch index out of array bounds"); + check_error(json_error_index_out_of_range, "Array index 1 out of range", + "<validation>", 1, 3, 3); + json_decref(j); + + /* NULL object key */ + j = json_pack("{si}", "foo", 42); + if (!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1)) + fail("json_unpack failed to catch null string pointer"); + check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2); + json_decref(j); + + /* Object key not found */ + j = json_pack("{si}", "foo", 42); + if (!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1)) + fail("json_unpack failed to catch null string pointer"); + check_error(json_error_item_not_found, "Object item not found: baz", "<validation>", + 1, 3, 3); + json_decref(j); + + /* + * Strict validation + */ + + j = json_pack("[iii]", 1, 2, 3); + rv = json_unpack(j, "[iii!]", &i1, &i2, &i3); + if (rv || i1 != 1 || i2 != 2 || i3 != 3) + fail("json_unpack array with strict validation failed"); + json_decref(j); + + j = json_pack("[iii]", 1, 2, 3); + if (!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2)) + fail("json_unpack array with strict validation failed"); + check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", + "<validation>", 1, 5, 5); + json_decref(j); + + /* Like above, but with JSON_STRICT instead of '!' format */ + j = json_pack("[iii]", 1, 2, 3); + if (!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2)) + fail("json_unpack array with strict validation failed"); + check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", + "<validation>", 1, 4, 4); + json_decref(j); + + j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42); + rv = json_unpack(j, "{sssi!}", "foo", &s, "baz", &i1); + if (rv || strcmp(s, "bar") != 0 || i1 != 42) + fail("json_unpack object with strict validation failed"); + json_decref(j); + + /* Unpack the same item twice */ + j = json_pack("{s:s, s:i, s:b}", "foo", "bar", "baz", 42, "quux", 1); + if (!json_unpack_ex(j, &error, 0, "{s:s,s:s!}", "foo", &s, "foo", &s)) + fail("json_unpack object with strict validation failed"); + { + const char *possible_errors[] = {"2 object item(s) left unpacked: baz, quux", + "2 object item(s) left unpacked: quux, baz"}; + check_errors(json_error_end_of_input_expected, possible_errors, 2, "<validation>", + 1, 10, 10); + } + json_decref(j); + + j = json_pack("[i,{s:i,s:n},[i,i]]", 1, "foo", 2, "bar", 3, 4); + if (json_unpack_ex(j, NULL, JSON_STRICT | JSON_VALIDATE_ONLY, "[i{sisn}[ii]]", "foo", + "bar")) + fail("json_unpack complex value with strict validation failed"); + json_decref(j); + + /* ! and * must be last */ + j = json_pack("[ii]", 1, 2); + if (!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2)) + fail("json_unpack failed to catch ! in the middle of an array"); + check_error(json_error_invalid_format, "Expected ']' after '!', got 'i'", "<format>", + 1, 4, 4); + + if (!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2)) + fail("json_unpack failed to catch * in the middle of an array"); + check_error(json_error_invalid_format, "Expected ']' after '*', got 'i'", "<format>", + 1, 4, 4); + json_decref(j); + + j = json_pack("{sssi}", "foo", "bar", "baz", 42); + if (!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1)) + fail("json_unpack failed to catch ! in the middle of an object"); + check_error(json_error_invalid_format, "Expected '}' after '!', got 's'", "<format>", + 1, 5, 5); + + if (!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1)) + fail("json_unpack failed to catch ! in the middle of an object"); + check_error(json_error_invalid_format, "Expected '}' after '*', got 's'", "<format>", + 1, 5, 5); + json_decref(j); + + /* Error in nested object */ + j = json_pack("{s{snsn}}", "foo", "bar", "baz"); + if (!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar")) + fail("json_unpack nested object with strict validation failed"); + check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", + "<validation>", 1, 7, 7); + json_decref(j); + + /* Error in nested array */ + j = json_pack("[[ii]]", 1, 2); + if (!json_unpack_ex(j, &error, 0, "[[i!]]", &i1)) + fail("json_unpack nested array with strict validation failed"); + check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", + "<validation>", 1, 5, 5); + json_decref(j); + + /* Optional values */ + j = json_object(); + i1 = 0; + if (json_unpack(j, "{s?i}", "foo", &i1)) + fail("json_unpack failed for optional key"); + if (i1 != 0) + fail("json_unpack unpacked an optional key"); + json_decref(j); + + i1 = 0; + j = json_pack("{si}", "foo", 42); + if (json_unpack(j, "{s?i}", "foo", &i1)) + fail("json_unpack failed for an optional value"); + if (i1 != 42) + fail("json_unpack failed to unpack an optional value"); + json_decref(j); + + j = json_object(); + i1 = i2 = i3 = 0; + if (json_unpack(j, "{s?[ii]s?{s{si}}}", "foo", &i1, &i2, "bar", "baz", "quux", &i3)) + fail("json_unpack failed for complex optional values"); + if (i1 != 0 || i2 != 0 || i3 != 0) + fail("json_unpack unexpectedly unpacked something"); + json_decref(j); + + j = json_pack("{s{si}}", "foo", "bar", 42); + if (json_unpack(j, "{s?{s?i}}", "foo", "bar", &i1)) + fail("json_unpack failed for complex optional values"); + if (i1 != 42) + fail("json_unpack failed to unpack"); + json_decref(j); + + /* Combine ? and ! */ + j = json_pack("{si}", "foo", 42); + i1 = i2 = 0; + if (json_unpack(j, "{sis?i!}", "foo", &i1, "bar", &i2)) + fail("json_unpack failed for optional values with strict mode"); + if (i1 != 42) + fail("json_unpack failed to unpack"); + if (i2 != 0) + fail("json_unpack failed to unpack"); + json_decref(j); + + /* But don't compensate a missing key with an optional one. */ + j = json_pack("{sisi}", "foo", 42, "baz", 43); + i1 = i2 = i3 = 0; + if (!json_unpack_ex(j, &error, 0, "{sis?i!}", "foo", &i1, "bar", &i2)) + fail("json_unpack failed for optional values with strict mode and " + "compensation"); + check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", + "<validation>", 1, 8, 8); + json_decref(j); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_version.c b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_version.c new file mode 100644 index 000000000..05e0e9614 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/test_version.c @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2019 Sean Bright <sean.bright@gmail.com> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#include "util.h" +#include <jansson.h> +#include <string.h> + +static void test_version_str(void) { + if (strcmp(jansson_version_str(), JANSSON_VERSION)) { + fail("jansson_version_str returned invalid version string"); + } +} + +static void test_version_cmp() { + if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION, + JANSSON_MICRO_VERSION)) { + fail("jansson_version_cmp equality check failed"); + } + + if (jansson_version_cmp(JANSSON_MAJOR_VERSION - 1, 0, 0) <= 0) { + fail("jansson_version_cmp less than check failed"); + } + + if (JANSSON_MINOR_VERSION) { + if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION - 1, + JANSSON_MICRO_VERSION) <= 0) { + fail("jansson_version_cmp less than check failed"); + } + } + + if (JANSSON_MICRO_VERSION) { + if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION, + JANSSON_MICRO_VERSION - 1) <= 0) { + fail("jansson_version_cmp less than check failed"); + } + } + + if (jansson_version_cmp(JANSSON_MAJOR_VERSION + 1, JANSSON_MINOR_VERSION, + JANSSON_MICRO_VERSION) >= 0) { + fail("jansson_version_cmp greater than check failed"); + } + + if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION + 1, + JANSSON_MICRO_VERSION) >= 0) { + fail("jansson_version_cmp greater than check failed"); + } + + if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION, + JANSSON_MICRO_VERSION + 1) >= 0) { + fail("jansson_version_cmp greater than check failed"); + } +} + +static void run_tests() { + test_version_str(); + test_version_cmp(); +} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/api/util.h b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/util.h new file mode 100644 index 000000000..d964c4930 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/api/util.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> + * + * Jansson is free software; you can redistribute it and/or modify + * it under the terms of the MIT license. See LICENSE for details. + */ + +#ifndef UTIL_H +#define UTIL_H + +#ifdef HAVE_CONFIG_H +#include <jansson_private_config.h> +#endif + +#include <stdio.h> +#include <stdlib.h> +#if HAVE_LOCALE_H +#include <locale.h> +#endif + +#include <jansson.h> + +#define failhdr fprintf(stderr, "%s:%d: ", __FILE__, __LINE__) + +#define fail(msg) \ + do { \ + failhdr; \ + fprintf(stderr, "%s\n", msg); \ + exit(1); \ + } while (0) + +/* Assumes json_error_t error */ +#define check_errors(code_, texts_, num_, source_, line_, column_, position_) \ + do { \ + int i_, found_ = 0; \ + if (json_error_code(&error) != code_) { \ + failhdr; \ + fprintf(stderr, "code: %d != %d\n", json_error_code(&error), code_); \ + exit(1); \ + } \ + for (i_ = 0; i_ < num_; i_++) { \ + if (strcmp(error.text, texts_[i_]) == 0) { \ + found_ = 1; \ + break; \ + } \ + } \ + if (!found_) { \ + failhdr; \ + if (num_ == 1) { \ + fprintf(stderr, "text: \"%s\" != \"%s\"\n", error.text, texts_[0]); \ + } else { \ + fprintf(stderr, "text: \"%s\" does not match\n", error.text); \ + } \ + exit(1); \ + } \ + if (strcmp(error.source, source_) != 0) { \ + failhdr; \ + \ + fprintf(stderr, "source: \"%s\" != \"%s\"\n", error.source, source_); \ + exit(1); \ + } \ + if (error.line != line_) { \ + failhdr; \ + fprintf(stderr, "line: %d != %d\n", error.line, line_); \ + exit(1); \ + } \ + if (error.column != column_) { \ + failhdr; \ + fprintf(stderr, "column: %d != %d\n", error.column, column_); \ + exit(1); \ + } \ + if (error.position != position_) { \ + failhdr; \ + fprintf(stderr, "position: %d != %d\n", error.position, position_); \ + exit(1); \ + } \ + } while (0) + +/* Assumes json_error_t error */ +#define check_error(code_, text_, source_, line_, column_, position_) \ + check_errors(code_, &text_, 1, source_, line_, column_, position_) + +static void run_tests(); + +int main() { +#ifdef HAVE_SETLOCALE + setlocale(LC_ALL, ""); +#endif + run_tests(); + return 0; +} + +#endif diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/input new file mode 100644 index 000000000..44e2ace7e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/input @@ -0,0 +1 @@ +[1, 2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/output new file mode 100644 index 000000000..fd8ef0957 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/array/output @@ -0,0 +1 @@ +[1, 2]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/env new file mode 100644 index 000000000..4474aaf14 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/env @@ -0,0 +1,2 @@ +JSON_COMPACT=1 +export JSON_COMPACT diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/input new file mode 100644 index 000000000..44e2ace7e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/input @@ -0,0 +1 @@ +[1, 2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/output new file mode 100644 index 000000000..3169929f6 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-array/output @@ -0,0 +1 @@ +[1,2]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/env new file mode 100644 index 000000000..93cb33dda --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/env @@ -0,0 +1,3 @@ +JSON_COMPACT=1 +HASHSEED=1 +export JSON_COMPACT HASHSEED diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/input new file mode 100644 index 000000000..062e54fb4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/input @@ -0,0 +1 @@ +{"a": 1, "b": 2} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/output new file mode 100644 index 000000000..73a5d70e3 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/compact-object/output @@ -0,0 +1 @@ +{"a":1,"b":2}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/env new file mode 100644 index 000000000..1b7b3e3f9 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/env @@ -0,0 +1,2 @@ +JSON_ENSURE_ASCII=1 +export JSON_ENSURE_ASCII diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/input new file mode 100644 index 000000000..69469cef5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/input @@ -0,0 +1,8 @@ +[ + "foo", + "å ä ö", + "foo åä", + "åä foo", + "å foo ä", + "clef g: 𝄞" +] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/output new file mode 100644 index 000000000..94fa79d2d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/ensure-ascii/output @@ -0,0 +1 @@ +["foo", "\u00E5 \u00E4 \u00F6", "foo \u00E5\u00E4", "\u00E5\u00E4 foo", "\u00E5 foo \u00E4", "clef g: \uD834\uDD1E"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/env new file mode 100644 index 000000000..d220f837c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/env @@ -0,0 +1,2 @@ +JSON_INDENT=4 +export JSON_INDENT diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/input new file mode 100644 index 000000000..44e2ace7e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/input @@ -0,0 +1 @@ +[1, 2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/output new file mode 100644 index 000000000..c57d705ba --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-array/output @@ -0,0 +1,4 @@ +[ + 1, + 2 +]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/env new file mode 100644 index 000000000..78fbfcc2e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/env @@ -0,0 +1,3 @@ +JSON_INDENT=4 +JSON_COMPACT=1 +export JSON_INDENT JSON_COMPACT diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/input new file mode 100644 index 000000000..44e2ace7e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/input @@ -0,0 +1 @@ +[1, 2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/output new file mode 100644 index 000000000..c57d705ba --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-array/output @@ -0,0 +1,4 @@ +[ + 1, + 2 +]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/env new file mode 100644 index 000000000..c73acc179 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/env @@ -0,0 +1,4 @@ +JSON_INDENT=4 +JSON_COMPACT=1 +HASHSEED=1 +export JSON_INDENT JSON_COMPACT HASHSEED diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/input new file mode 100644 index 000000000..062e54fb4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/input @@ -0,0 +1 @@ +{"a": 1, "b": 2} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/output new file mode 100644 index 000000000..9cc42948d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-compact-object/output @@ -0,0 +1,4 @@ +{ + "a":1, + "b":2 +}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/env new file mode 100644 index 000000000..961558ca2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/env @@ -0,0 +1,3 @@ +JSON_INDENT=4 +HASHSEED=1 +export JSON_INDENT HASHSEED diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/input new file mode 100644 index 000000000..062e54fb4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/input @@ -0,0 +1 @@ +{"a": 1, "b": 2} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/output new file mode 100644 index 000000000..0fbddba44 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/indent-object/output @@ -0,0 +1,4 @@ +{ + "a": 1, + "b": 2 +}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/env new file mode 100644 index 000000000..9120b0351 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/env @@ -0,0 +1,2 @@ +HASHSEED=1 +export HASHSEED diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/input new file mode 100644 index 000000000..062e54fb4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/input @@ -0,0 +1 @@ +{"a": 1, "b": 2} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/output new file mode 100644 index 000000000..ecd219f72 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/object/output @@ -0,0 +1 @@ +{"a": 1, "b": 2}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/env new file mode 100644 index 000000000..4d9d20659 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/env @@ -0,0 +1,2 @@ +JSON_PRESERVE_ORDER=1 +export JSON_PRESERVE_ORDER diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/input new file mode 100644 index 000000000..27bcf18a0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/input @@ -0,0 +1 @@ +{"foo": 1, "bar": 2, "asdf": 3, "deadbeef": 4, "badc0ffee": 5, "qwerty": 6} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/output new file mode 100644 index 000000000..7a443f684 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/preserve-order/output @@ -0,0 +1 @@ +{"foo": 1, "bar": 2, "asdf": 3, "deadbeef": 4, "badc0ffee": 5, "qwerty": 6}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/env new file mode 100644 index 000000000..9c52cbcd6 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/env @@ -0,0 +1,2 @@ +JSON_REAL_PRECISION=4 +export JSON_REAL_PRECISION diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/input new file mode 100644 index 000000000..e291165c1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/input @@ -0,0 +1 @@ +[1.23456789, 1.0, 1.0000000000000002] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/output new file mode 100644 index 000000000..f273c73e5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/real-precision/output @@ -0,0 +1 @@ +[1.235, 1.0, 1.0]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/run new file mode 100755 index 000000000..5db7d5e5c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/run @@ -0,0 +1,32 @@ +#!/bin/sh +# +# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> +# +# Jansson is free software; you can redistribute it and/or modify +# it under the terms of the MIT license. See LICENSE for details. + +is_test() { + test -d $test_path +} + +run_test() { + ( + if [ -f $test_path/env ]; then + . $test_path/env + fi + $json_process --env <$test_path/input >$test_log/stdout 2>$test_log/stderr + ) + valgrind_check $test_log/stderr || return 1 + cmp -s $test_path/output $test_log/stdout +} + +show_error() { + valgrind_show_error && return + + echo "EXPECTED OUTPUT:" + nl -bn $test_path/output + echo "ACTUAL OUTPUT:" + nl -bn $test_log/stdout +} + +. $top_srcdir/test/scripts/run-tests.sh diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/env new file mode 100644 index 000000000..3ef24cb7b --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/env @@ -0,0 +1,2 @@ +JSON_SORT_KEYS=1 +export JSON_SORT_KEYS diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/input new file mode 100644 index 000000000..66951d6b0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/input @@ -0,0 +1 @@ +{"foo": 1, "bar": 2, "baz": 3, "quux": 4} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/output new file mode 100644 index 000000000..132d9df31 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/encoding-flags/sort-keys/output @@ -0,0 +1 @@ +{"bar": 2, "baz": 3, "foo": 1, "quux": 4}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/error new file mode 100644 index 000000000..762d2c4b1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xed near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/input new file mode 100644 index 000000000..515dd933c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/encoded-surrogate-half/input @@ -0,0 +1 @@ +[" <-- encoded surrogate half"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/error new file mode 100644 index 000000000..b16dc171e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/error @@ -0,0 +1,2 @@ +1 3 3 +unable to decode byte 0xe5 near '"\' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/input new file mode 100644 index 000000000..57c8beef6 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-after-backslash/input @@ -0,0 +1 @@ +["\"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/error new file mode 100644 index 000000000..be15386df --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/error @@ -0,0 +1,2 @@ +1 1 1 +unable to decode byte 0xe5 diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/input new file mode 100644 index 000000000..ebefcd6f8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-array/input @@ -0,0 +1 @@ +[] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/error new file mode 100644 index 000000000..01b447639 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/error @@ -0,0 +1,2 @@ +1 4 4 +unable to decode byte 0xe5 near '123' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/input new file mode 100644 index 000000000..e512f9ae0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-bigger-int/input @@ -0,0 +1 @@ +[123] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/error new file mode 100644 index 000000000..c13583dd8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/error @@ -0,0 +1,2 @@ +1 4 4 +unable to decode byte 0xe5 near '"\u' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/input new file mode 100644 index 000000000..2b271b82f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-escape/input @@ -0,0 +1 @@ +["\u"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/error new file mode 100644 index 000000000..c7b20b7a2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/error @@ -0,0 +1,2 @@ +1 4 4 +unable to decode byte 0xe5 near '1e1' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/input new file mode 100644 index 000000000..d8e83c595 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-exponent/input @@ -0,0 +1 @@ +[1e1] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/error new file mode 100644 index 000000000..33dfc2324 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xe5 near 'a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/input new file mode 100644 index 000000000..ef038514a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-identifier/input @@ -0,0 +1 @@ +[a] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/error new file mode 100644 index 000000000..8f08970c1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xe5 near '0' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/input new file mode 100644 index 000000000..371226e4c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-int/input @@ -0,0 +1 @@ +[0] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/error new file mode 100644 index 000000000..b7660e327 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/error @@ -0,0 +1,2 @@ +1 3 3 +unable to decode byte 0xe5 near '1e' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/input new file mode 100644 index 000000000..17fc29c90 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-real-after-e/input @@ -0,0 +1 @@ +[1e] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/error new file mode 100644 index 000000000..0b7039a52 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xe5 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/input new file mode 100644 index 000000000..00b79c0af --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/invalid-utf-8-in-string/input @@ -0,0 +1 @@ +[" <-- invalid UTF-8"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/error new file mode 100644 index 000000000..8e9a51119 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/error @@ -0,0 +1,2 @@ +1 0 0 +unable to decode byte 0xe5 diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/input new file mode 100644 index 000000000..eb8079699 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-invalid-utf-8/input @@ -0,0 +1 @@ + diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/error new file mode 100644 index 000000000..86bbad3c8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0x81 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/input new file mode 100644 index 000000000..62a26b6fb --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/lone-utf-8-continuation-byte/input @@ -0,0 +1 @@ +[""] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/error new file mode 100644 index 000000000..d07ccb3e5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xf4 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/input new file mode 100644 index 000000000..1216186a7 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/not-in-unicode-range/input @@ -0,0 +1 @@ +[""] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/error new file mode 100644 index 000000000..8a05abaed --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xe0 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/input new file mode 100644 index 000000000..0bf909f7b --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-3-byte-encoding/input @@ -0,0 +1 @@ +[" <-- overlong encoding"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/error new file mode 100644 index 000000000..7e19c5fe4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xf0 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/input new file mode 100644 index 000000000..c6b631350 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-4-byte-encoding/input @@ -0,0 +1 @@ +[" <-- overlong encoding"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/error new file mode 100644 index 000000000..1d382edd7 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xc1 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/input new file mode 100644 index 000000000..ef6e10a34 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/overlong-ascii-encoding/input @@ -0,0 +1 @@ +[""] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/error new file mode 100644 index 000000000..d018f5ff3 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xfd near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/input new file mode 100644 index 000000000..ba6017002 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/restricted-utf-8/input @@ -0,0 +1 @@ +[""] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/run new file mode 100755 index 000000000..369c43da5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/run @@ -0,0 +1,27 @@ +#!/bin/sh +# +# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> +# +# Jansson is free software; you can redistribute it and/or modify +# it under the terms of the MIT license. See LICENSE for details. + +is_test() { + test -d $test_path +} + +run_test() { + $json_process --env <$test_path/input >$test_log/stdout 2>$test_log/stderr + valgrind_check $test_log/stderr || return 1 + cmp -s $test_path/error $test_log/stderr +} + +show_error() { + valgrind_show_error && return + + echo "EXPECTED ERROR:" + nl -bn $test_path/error + echo "ACTUAL ERROR:" + nl -bn $test_log/stderr +} + +. $top_srcdir/test/scripts/run-tests.sh diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/error new file mode 100644 index 000000000..8a05abaed --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/error @@ -0,0 +1,2 @@ +1 2 2 +unable to decode byte 0xe0 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/input new file mode 100644 index 000000000..bce9e18bf --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid-unicode/truncated-utf-8/input @@ -0,0 +1 @@ +[" <-- truncated UTF-8"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/error new file mode 100644 index 000000000..79bb2a0eb --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/error @@ -0,0 +1,2 @@ +1 2 2 +invalid token near ''' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/input new file mode 100644 index 000000000..f2dd4d224 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/apostrophe/input @@ -0,0 +1 @@ +[' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/error new file mode 100644 index 000000000..a4d814280 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/error @@ -0,0 +1,2 @@ +1 1 1 +'[' or '{' expected near 'a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/input new file mode 100644 index 000000000..c2c0208ed --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/ascii-unicode-identifier/input @@ -0,0 +1 @@ +aå diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/error new file mode 100644 index 000000000..ce046213c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/error @@ -0,0 +1,2 @@ +1 2 2 +string or '}' expected near ',' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/input new file mode 100644 index 000000000..74a6628d4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/brace-comma/input @@ -0,0 +1 @@ +{, diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/error new file mode 100644 index 000000000..ce0a912bf --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/error @@ -0,0 +1,2 @@ +1 2 2 +unexpected token near ',' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/input new file mode 100644 index 000000000..5b911f11d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-comma/input @@ -0,0 +1 @@ +[, diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.normal new file mode 100644 index 000000000..0248b114a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.normal @@ -0,0 +1,2 @@ +2 0 4 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.strip new file mode 100644 index 000000000..f89b38fcb --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/error.strip @@ -0,0 +1,2 @@ +1 3 3 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/input new file mode 100644 index 000000000..874691b1d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/bracket-one-comma/input @@ -0,0 +1 @@ +[1, diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/error new file mode 100644 index 000000000..f45da6f82 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/error @@ -0,0 +1,2 @@ +1 0 0 +'[' or '{' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/input new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/empty/input diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/error new file mode 100644 index 000000000..cae86c246 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/error @@ -0,0 +1,2 @@ +1 4 4 +unexpected token near ']' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/input new file mode 100644 index 000000000..e8b1a170f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-array/input @@ -0,0 +1 @@ +[1,] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/error new file mode 100644 index 000000000..5baeea447 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/error @@ -0,0 +1,2 @@ +6 1 17 +unexpected token near ']' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/input new file mode 100644 index 000000000..bcb2a7526 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/extra-comma-in-multiline-array/input @@ -0,0 +1,6 @@ +[1, +2, +3, +4, +5, +] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/error new file mode 100644 index 000000000..5d2dec374 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/error @@ -0,0 +1,2 @@ +2 3 11 +end of file expected near 'foo' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/input new file mode 100644 index 000000000..3614ac78f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-after-newline/input @@ -0,0 +1,2 @@ +[1,2,3] +foo diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/error new file mode 100644 index 000000000..cdd817572 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/error @@ -0,0 +1,2 @@ +1 10 10 +end of file expected near 'foo' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/input new file mode 100644 index 000000000..55aee53d2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/garbage-at-the-end/input @@ -0,0 +1 @@ +[1,2,3]foo diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/error new file mode 100644 index 000000000..64e0536aa --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/error @@ -0,0 +1,2 @@ +1 2 2 +invalid token near '0' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/input new file mode 100644 index 000000000..12f67e2c2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/integer-starting-with-zero/input @@ -0,0 +1 @@ +[012] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/error new file mode 100644 index 000000000..d9863f73b --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/error @@ -0,0 +1,2 @@ +1 4 4 +invalid escape near '"\a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/input new file mode 100644 index 000000000..64c7b70d9 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-escape/input @@ -0,0 +1 @@ +["\a <-- invalid escape"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/error new file mode 100644 index 000000000..496c6aba2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/error @@ -0,0 +1,2 @@ +1 5 5 +invalid token near 'troo' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/input new file mode 100644 index 000000000..3d2860da1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-identifier/input @@ -0,0 +1 @@ +[troo diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/error new file mode 100644 index 000000000..f2526c51e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/error @@ -0,0 +1,2 @@ +1 8 8 +']' expected near 'foo' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/input new file mode 100644 index 000000000..6196980ec --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-integer/input @@ -0,0 +1 @@ +[-123foo] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/error new file mode 100644 index 000000000..933158ae5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/error @@ -0,0 +1,2 @@ +1 12 12 +']' expected near 'foo' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/input new file mode 100644 index 000000000..3c763d334 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-negative-real/input @@ -0,0 +1 @@ +[-123.123foo] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/error new file mode 100644 index 000000000..e5a2359e6 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/error @@ -0,0 +1,2 @@ +1 62 62 +invalid Unicode '\uD888\u3210' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/input new file mode 100644 index 000000000..b21453f6f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-second-surrogate/input @@ -0,0 +1 @@ +["\uD888\u3210 (first surrogate and invalid second surrogate)"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/error new file mode 100644 index 000000000..221c762eb --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/error @@ -0,0 +1,2 @@ +1 5 5 +invalid escape near '"\uq' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/input new file mode 100644 index 000000000..f381e85b8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/invalid-unicode-escape/input @@ -0,0 +1 @@ +["\uqqqq <-- invalid unicode escape"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.normal new file mode 100644 index 000000000..00dc765b9 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.normal @@ -0,0 +1,2 @@ +2 0 2 +string or '}' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.strip new file mode 100644 index 000000000..bb1c04745 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/error.strip @@ -0,0 +1,2 @@ +1 1 1 +string or '}' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/input new file mode 100644 index 000000000..98232c64f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-brace/input @@ -0,0 +1 @@ +{ diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.normal new file mode 100644 index 000000000..f463928f8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.normal @@ -0,0 +1,2 @@ +2 0 2 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.strip new file mode 100644 index 000000000..2bc07ea0c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/error.strip @@ -0,0 +1,2 @@ +1 1 1 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/input new file mode 100644 index 000000000..558ed37d9 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-open-bracket/input @@ -0,0 +1 @@ +[ diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/error new file mode 100644 index 000000000..bc5f34e11 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/error @@ -0,0 +1,2 @@ +1 40 40 +invalid Unicode '\uDFAA' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/input new file mode 100644 index 000000000..328e35c82 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/lone-second-surrogate/input @@ -0,0 +1 @@ +["\uDFAA (second surrogate on it's own)"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/error new file mode 100644 index 000000000..b3a78b978 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/error @@ -0,0 +1,2 @@ +1 2 2 +invalid token near '-' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/input new file mode 100644 index 000000000..033788355 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/minus-sign-without-number/input @@ -0,0 +1 @@ +[-foo] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/error new file mode 100644 index 000000000..36adc34b4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/error @@ -0,0 +1,2 @@ +1 3 3 +invalid token near '-0' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/input new file mode 100644 index 000000000..6fbb7a2f8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/negative-integer-starting-with-zero/input @@ -0,0 +1 @@ +[-012] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/error new file mode 100644 index 000000000..3ec685b5d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/error @@ -0,0 +1,2 @@ +1 15 15 +NUL byte in object key not supported near '"foo\u0000bar"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/input new file mode 100644 index 000000000..593f0f67f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-object-key/input @@ -0,0 +1 @@ +{"foo\u0000bar": 42}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/error new file mode 100644 index 000000000..45f9bd817 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/error @@ -0,0 +1,2 @@ +1 12 12 +control character 0x0 near '"null byte ' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/input Binary files differnew file mode 100644 index 000000000..268d1f194 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/input diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/nostrip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/nostrip new file mode 100644 index 000000000..80f4bf761 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-in-string/nostrip @@ -0,0 +1,2 @@ +The embedded NULL byte breaks json_loads(), which is used instead of +json_loadf() in the stripped tests. diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/error new file mode 100644 index 000000000..44d4def92 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/error @@ -0,0 +1,2 @@ +1 2 2 +invalid token near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/input Binary files differnew file mode 100644 index 000000000..aa550eb0c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/input diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/nostrip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/nostrip new file mode 100644 index 000000000..80f4bf761 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-byte-outside-string/nostrip @@ -0,0 +1,2 @@ +The embedded NULL byte breaks json_loads(), which is used instead of +json_loadf() in the stripped tests. diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/error new file mode 100644 index 000000000..3f5c8c6ca --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/error @@ -0,0 +1,2 @@ +1 33 33 +\u0000 is not allowed without JSON_ALLOW_NUL diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/input new file mode 100644 index 000000000..dbc9c9a99 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null-escape-in-string/input @@ -0,0 +1 @@ +["null escape \u0000 not allowed"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/error new file mode 100644 index 000000000..1f5d46490 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/error @@ -0,0 +1,2 @@ +1 4 4 +'[' or '{' expected near 'null' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/input new file mode 100644 index 000000000..19765bd50 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/null/input @@ -0,0 +1 @@ +null diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/error new file mode 100644 index 000000000..23fab01f6 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/error @@ -0,0 +1,2 @@ +1 2 2 +string or '}' expected near ''' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/input new file mode 100644 index 000000000..52b290574 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-apostrophes/input @@ -0,0 +1 @@ +{'a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/error new file mode 100644 index 000000000..06c4ec1c2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/error @@ -0,0 +1,2 @@ +1 12 12 +'}' expected near '123' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/input new file mode 100644 index 000000000..62c19d742 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-garbage-at-end/input @@ -0,0 +1 @@ +{"a":"a" 123} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.normal new file mode 100644 index 000000000..0248b114a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.normal @@ -0,0 +1,2 @@ +2 0 4 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.strip new file mode 100644 index 000000000..f89b38fcb --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/error.strip @@ -0,0 +1,2 @@ +1 3 3 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/input new file mode 100644 index 000000000..ca9ec378e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-in-unterminated-array/input @@ -0,0 +1 @@ +[{} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.normal new file mode 100644 index 000000000..78d84f7b7 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.normal @@ -0,0 +1,2 @@ +2 0 5 +':' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.strip new file mode 100644 index 000000000..528e266d2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/error.strip @@ -0,0 +1,2 @@ +1 4 4 +':' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/input new file mode 100644 index 000000000..107e6265c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-colon/input @@ -0,0 +1 @@ +{"a" diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.normal new file mode 100644 index 000000000..47ad902dd --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.normal @@ -0,0 +1,2 @@ +2 0 6 +unexpected token near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.strip new file mode 100644 index 000000000..b36c5e2bc --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/error.strip @@ -0,0 +1,2 @@ +1 5 5 +unexpected token near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/input new file mode 100644 index 000000000..f68f26269 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-no-value/input @@ -0,0 +1 @@ +{"a": diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.normal new file mode 100644 index 000000000..2ad76d473 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.normal @@ -0,0 +1,2 @@ +1 7 7 +unexpected newline near '"a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.strip new file mode 100644 index 000000000..385afb534 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/error.strip @@ -0,0 +1,2 @@ +1 7 7 +premature end of input near '"a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/input new file mode 100644 index 000000000..b854d7e18 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/object-unterminated-value/input @@ -0,0 +1 @@ +{"a":"a diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/error new file mode 100644 index 000000000..b40ffa9b5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/error @@ -0,0 +1,2 @@ +1 3 3 +invalid token near '1e' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/input new file mode 100644 index 000000000..6a945ac0f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-garbage-after-e/input @@ -0,0 +1 @@ +[1ea] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/error new file mode 100644 index 000000000..d7f8e412d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/error @@ -0,0 +1,2 @@ +1 15 15 +real number overflow near '-123123e100000' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/input new file mode 100644 index 000000000..b5bd21c46 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-negative-overflow/input @@ -0,0 +1 @@ +[-123123e100000] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/error new file mode 100644 index 000000000..55883c981 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/error @@ -0,0 +1,2 @@ +1 14 14 +real number overflow near '123123e100000' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/input new file mode 100644 index 000000000..524e53b31 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-positive-overflow/input @@ -0,0 +1 @@ +[123123e100000] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/error new file mode 100644 index 000000000..b40ffa9b5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/error @@ -0,0 +1,2 @@ +1 3 3 +invalid token near '1e' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/input new file mode 100644 index 000000000..1d67b7b82 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-e/input @@ -0,0 +1 @@ +[1e] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/error new file mode 100644 index 000000000..db972e8e1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/error @@ -0,0 +1,2 @@ +1 3 3 +invalid token near '1.' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/input new file mode 100644 index 000000000..b652b3fe0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/real-truncated-at-point/input @@ -0,0 +1 @@ +[1.] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/error new file mode 100644 index 000000000..11e0537ff --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/error @@ -0,0 +1,2 @@ +1 2049 2049 +maximum parsing depth reached near '[' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/input new file mode 100644 index 000000000..bfa47d9d1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/recursion-depth/input @@ -0,0 +1 @@ +[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[ diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/run new file mode 100755 index 000000000..d1d490c63 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/run @@ -0,0 +1,57 @@ +#!/bin/sh +# +# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> +# +# Jansson is free software; you can redistribute it and/or modify +# it under the terms of the MIT license. See LICENSE for details. + +is_test() { + test -d $test_path +} + +do_run() { + variant=$1 + s=".$1" + + strip=0 + if [ "$variant" = "strip" ]; then + # This test should not be stripped + [ -f $test_path/nostrip ] && return + strip=1 + fi + + STRIP=$strip $json_process --env \ + <$test_path/input >$test_log/stdout$s 2>$test_log/stderr$s + valgrind_check $test_log/stderr$s || return 1 + + ref=error + [ -f $test_path/error$s ] && ref=error$s + + if ! cmp -s $test_path/$ref $test_log/stderr$s; then + echo $variant > $test_log/variant + return 1 + fi +} + +run_test() { + do_run normal && do_run strip +} + +show_error() { + valgrind_show_error && return + + read variant < $test_log/variant + s=".$variant" + + echo "VARIANT: $variant" + + echo "EXPECTED ERROR:" + ref=error + [ -f $test_path/error$s ] && ref=error$s + nl -bn $test_path/$ref + + echo "ACTUAL ERROR:" + nl -bn $test_log/stderr$s +} + +. $top_srcdir/test/scripts/run-tests.sh diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/error new file mode 100644 index 000000000..9e2f76ed2 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/error @@ -0,0 +1,2 @@ +1 2 2 +control character 0x9 near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/input new file mode 100644 index 000000000..3ebae0953 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/tab-character-in-string/input @@ -0,0 +1 @@ +[" <-- tab character"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/error new file mode 100644 index 000000000..a0640b9a9 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/error @@ -0,0 +1,2 @@ +1 32 32 +too big negative integer diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/input new file mode 100644 index 000000000..d6c26f1cf --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-negative-integer/input @@ -0,0 +1 @@ +[-123123123123123123123123123123] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/error new file mode 100644 index 000000000..3bdbefd53 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/error @@ -0,0 +1,2 @@ +1 31 31 +too big integer diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/input new file mode 100644 index 000000000..27c855399 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/too-big-positive-integer/input @@ -0,0 +1 @@ +[123123123123123123123123123123] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/error new file mode 100644 index 000000000..1b99f061a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/error @@ -0,0 +1,2 @@ +1 46 46 +invalid Unicode '\uDADA' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/input new file mode 100644 index 000000000..2b340f4ad --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/truncated-unicode-surrogate/input @@ -0,0 +1 @@ +["\uDADA (first surrogate without the second)"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/error new file mode 100644 index 000000000..178b0dd4d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/error @@ -0,0 +1,2 @@ +1 1 2 +'[' or '{' expected near 'å' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/input new file mode 100644 index 000000000..aad321caf --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unicode-identifier/input @@ -0,0 +1 @@ +å diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.normal new file mode 100644 index 000000000..5b19804bc --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.normal @@ -0,0 +1,2 @@ +2 0 3 +string or '}' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.strip new file mode 100644 index 000000000..da2bb22f1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/error.strip @@ -0,0 +1,2 @@ +1 2 2 +string or '}' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/input new file mode 100644 index 000000000..cd9dc6482 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array-and-object/input @@ -0,0 +1 @@ +[{ diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.normal new file mode 100644 index 000000000..8025ed1b0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.normal @@ -0,0 +1,2 @@ +2 0 5 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.strip new file mode 100644 index 000000000..495d0f7c4 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/error.strip @@ -0,0 +1,2 @@ +1 4 4 +']' expected near end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/input new file mode 100644 index 000000000..727ee8106 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-array/input @@ -0,0 +1 @@ +["a" diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.normal new file mode 100644 index 000000000..3d646abda --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.normal @@ -0,0 +1,2 @@ +1 2 2 +unexpected newline near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.strip new file mode 100644 index 000000000..94f194715 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/error.strip @@ -0,0 +1,2 @@ +1 2 2 +premature end of input near '"' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/input new file mode 100644 index 000000000..4117452de --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-empty-key/input @@ -0,0 +1 @@ +{" diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.normal new file mode 100644 index 000000000..5f09b77da --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.normal @@ -0,0 +1,2 @@ +1 3 3 +unexpected newline near '"a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.strip new file mode 100644 index 000000000..8b6bec430 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/error.strip @@ -0,0 +1,2 @@ +1 3 3 +premature end of input near '"a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/input new file mode 100644 index 000000000..705948c64 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-key/input @@ -0,0 +1 @@ +{"a diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/error b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/error new file mode 100644 index 000000000..ed97be73e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/error @@ -0,0 +1,2 @@ +1 2 2 +string or '}' expected near '[' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/input new file mode 100644 index 000000000..da35a8620 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-object-and-array/input @@ -0,0 +1 @@ +{[ diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.normal b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.normal new file mode 100644 index 000000000..5f09b77da --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.normal @@ -0,0 +1,2 @@ +1 3 3 +unexpected newline near '"a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.strip b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.strip new file mode 100644 index 000000000..8b6bec430 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/error.strip @@ -0,0 +1,2 @@ +1 3 3 +premature end of input near '"a' diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/input new file mode 100644 index 000000000..38ab6b04c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/invalid/unterminated-string/input @@ -0,0 +1 @@ +["a diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/env b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/env new file mode 100644 index 000000000..bd89eff9d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/env @@ -0,0 +1 @@ +JSON_SORT_KEYS=1
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/input new file mode 100644 index 000000000..1b9bbb949 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/input @@ -0,0 +1,5 @@ +[1,2,3,4, +"a", "b", "c", +{"foo": "bar", "core": "dump"}, +true, false, true, true, null, false +] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/output new file mode 100644 index 000000000..7aefe5642 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/complex-array/output @@ -0,0 +1 @@ +[1, 2, 3, 4, "a", "b", "c", {"core": "dump", "foo": "bar"}, true, false, true, true, null, false]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/input new file mode 100644 index 000000000..fe51488c7 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/input @@ -0,0 +1 @@ +[] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/output new file mode 100644 index 000000000..0637a088a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-array/output @@ -0,0 +1 @@ +[]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/input new file mode 100644 index 000000000..93d51406d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/input @@ -0,0 +1 @@ +[{}] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/output new file mode 100644 index 000000000..ee1aac42b --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object-in-array/output @@ -0,0 +1 @@ +[{}]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/input new file mode 100644 index 000000000..0967ef424 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/input @@ -0,0 +1 @@ +{} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/output new file mode 100644 index 000000000..9e26dfeeb --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-object/output @@ -0,0 +1 @@ +{}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/input new file mode 100644 index 000000000..66a1e1856 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/input @@ -0,0 +1 @@ +[""] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/output new file mode 100644 index 000000000..93b6be2bc --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/empty-string/output @@ -0,0 +1 @@ +[""]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/input new file mode 100644 index 000000000..9a98545c0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/input @@ -0,0 +1 @@ +["\u0012 escaped control character"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/output new file mode 100644 index 000000000..07221b78d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/escaped-utf-control-char/output @@ -0,0 +1 @@ +["\u0012 escaped control character"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/input new file mode 100644 index 000000000..434365202 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/input @@ -0,0 +1 @@ +[false] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/output new file mode 100644 index 000000000..67b2f0760 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/false/output @@ -0,0 +1 @@ +[false]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/input new file mode 100644 index 000000000..a96d5cdb3 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/input @@ -0,0 +1 @@ +[-123] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/output new file mode 100644 index 000000000..8e30f8bd9 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-int/output @@ -0,0 +1 @@ +[-123]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/input new file mode 100644 index 000000000..2363a1ac0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/input @@ -0,0 +1 @@ +[-1] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/output new file mode 100644 index 000000000..99d21a2a0 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-one/output @@ -0,0 +1 @@ +[-1]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/input new file mode 100644 index 000000000..40fc49c71 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/input @@ -0,0 +1 @@ +[-0] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/output new file mode 100644 index 000000000..6e7ea636e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/negative-zero/output @@ -0,0 +1 @@ +[0]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/input new file mode 100644 index 000000000..62864b313 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/input @@ -0,0 +1 @@ +[null] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/output new file mode 100644 index 000000000..500db4a86 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/null/output @@ -0,0 +1 @@ +[null]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/input new file mode 100644 index 000000000..8bda4685d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/input @@ -0,0 +1 @@ +["\u002c one-byte UTF-8"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/output new file mode 100644 index 000000000..c33d250ff --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/one-byte-utf-8/output @@ -0,0 +1 @@ +[", one-byte UTF-8"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/input new file mode 100644 index 000000000..1e9fa5153 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/input @@ -0,0 +1 @@ +[1E-2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/output new file mode 100644 index 000000000..75b9ef92c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-negative-exponent/output @@ -0,0 +1 @@ +[0.01]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/input new file mode 100644 index 000000000..6a6ab9337 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/input @@ -0,0 +1 @@ +[1E+2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/output new file mode 100644 index 000000000..d8ff702a1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e-positive-exponent/output @@ -0,0 +1 @@ +[100.0]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/input new file mode 100644 index 000000000..e70322356 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/input @@ -0,0 +1 @@ +[1E22] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/output new file mode 100644 index 000000000..9a739f21f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-capital-e/output @@ -0,0 +1 @@ +[1e22]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/input new file mode 100644 index 000000000..b2a69b9a3 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/input @@ -0,0 +1 @@ +[123e45] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/output new file mode 100644 index 000000000..5ffc7196d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-exponent/output @@ -0,0 +1 @@ +[1.2299999999999999e47]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/input new file mode 100644 index 000000000..0c1660d1e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/input @@ -0,0 +1 @@ +[123.456e78] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/output new file mode 100644 index 000000000..66a3c8186 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-fraction-exponent/output @@ -0,0 +1 @@ +[1.23456e80]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/input new file mode 100644 index 000000000..daa4af932 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/input @@ -0,0 +1 @@ +[1e-2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/output new file mode 100644 index 000000000..75b9ef92c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-negative-exponent/output @@ -0,0 +1 @@ +[0.01]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/input new file mode 100644 index 000000000..f3780773a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/input @@ -0,0 +1 @@ +[1e+2] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/output new file mode 100644 index 000000000..d8ff702a1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-positive-exponent/output @@ -0,0 +1 @@ +[100.0]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/input new file mode 100644 index 000000000..df6065345 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/input @@ -0,0 +1 @@ +[1.8011670033376514e-308] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/output new file mode 100644 index 000000000..e6b0a58e8 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-subnormal-number/output @@ -0,0 +1 @@ +[1.8011670033376514e-308]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/input new file mode 100644 index 000000000..dc709960a --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/input @@ -0,0 +1 @@ +[123e-10000000] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/output new file mode 100644 index 000000000..92df1df1d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/real-underflow/output @@ -0,0 +1 @@ +[0.0]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/run b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/run new file mode 100755 index 000000000..d99548960 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/run @@ -0,0 +1,56 @@ +#!/bin/sh +# +# Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org> +# +# Jansson is free software; you can redistribute it and/or modify +# it under the terms of the MIT license. See LICENSE for details. + +JSON_SORT_KEYS=1 +export JSON_SORT_KEYS + +is_test() { + test -d $test_path +} + +do_run() { + variant=$1 + s=".$1" + + strip=0 + [ "$variant" = "strip" ] && strip=1 + + STRIP=$strip $json_process --env \ + <$test_path/input >$test_log/stdout$s 2>$test_log/stderr$s + valgrind_check $test_log/stderr$s || return 1 + + ref=output + [ -f $test_path/output$s ] && ref=output$s + + if ! cmp -s $test_path/$ref $test_log/stdout$s; then + echo $variant > $test_log/variant + return 1 + fi +} + +run_test() { + do_run normal && do_run strip +} + +show_error() { + valgrind_show_error && return + + read variant < $test_log/variant + s=".$variant" + + echo "VARIANT: $variant" + + echo "EXPECTED OUTPUT:" + ref=output + [ -f $test_path/output$s ] && ref=output$s + nl -bn $test_path/$ref + + echo "ACTUAL OUTPUT:" + nl -bn $test_log/stdout$s +} + +. $top_srcdir/test/scripts/run-tests.sh diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/input new file mode 100644 index 000000000..0c3426d4c --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/input @@ -0,0 +1 @@ +["a"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/output new file mode 100644 index 000000000..eac5f7b46 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/short-string/output @@ -0,0 +1 @@ +["a"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/input new file mode 100644 index 000000000..929b215c1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/input @@ -0,0 +1 @@ +["abcdefghijklmnopqrstuvwxyz1234567890 "] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/output new file mode 100644 index 000000000..90358ab70 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-ascii-string/output @@ -0,0 +1 @@ +["abcdefghijklmnopqrstuvwxyz1234567890 "]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/input new file mode 100644 index 000000000..111bb8686 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/input @@ -0,0 +1 @@ +[0] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/output new file mode 100644 index 000000000..6e7ea636e --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-0/output @@ -0,0 +1 @@ +[0]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/input new file mode 100644 index 000000000..7660873d1 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/input @@ -0,0 +1 @@ +[1] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/output new file mode 100644 index 000000000..bace2a0be --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-1/output @@ -0,0 +1 @@ +[1]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/input new file mode 100644 index 000000000..3214bfe58 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/input @@ -0,0 +1 @@ +[123] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/output new file mode 100644 index 000000000..e47f69afc --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-int-123/output @@ -0,0 +1 @@ +[123]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/input new file mode 100644 index 000000000..a34fb4907 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/input @@ -0,0 +1 @@ +{"a":[]} diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/output new file mode 100644 index 000000000..982abe826 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-object/output @@ -0,0 +1 @@ +{"a": []}
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/input new file mode 100644 index 000000000..0fed7df36 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/input @@ -0,0 +1 @@ +[123.456789] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/output new file mode 100644 index 000000000..b02878e5f --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/simple-real/output @@ -0,0 +1 @@ +[123.456789]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/input new file mode 100644 index 000000000..d994564d3 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/input @@ -0,0 +1 @@ +["\"\\\/\b\f\n\r\t"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/output new file mode 100644 index 000000000..ca5c1c658 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/string-escapes/output @@ -0,0 +1 @@ +["\"\\/\b\f\n\r\t"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/input new file mode 100644 index 000000000..ccc0bfa57 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/input @@ -0,0 +1 @@ +["\u0821 three-byte UTF-8"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/output new file mode 100644 index 000000000..c44d124e7 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/three-byte-utf-8/output @@ -0,0 +1 @@ +["ࠡ three-byte UTF-8"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/input new file mode 100644 index 000000000..29513c491 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/input @@ -0,0 +1 @@ +[true] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/output new file mode 100644 index 000000000..de601e305 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/true/output @@ -0,0 +1 @@ +[true]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/input new file mode 100644 index 000000000..05ae854b5 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/input @@ -0,0 +1 @@ +["\u0123 two-byte UTF-8"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/output new file mode 100644 index 000000000..1f0988d94 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/two-byte-utf-8/output @@ -0,0 +1 @@ +["ģ two-byte UTF-8"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/input new file mode 100644 index 000000000..20dc64a45 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/input @@ -0,0 +1 @@ +["€þıœəßð some utf-8 ĸʒ×ŋµåäö𝄞"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/output new file mode 100644 index 000000000..53728650d --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-8-string/output @@ -0,0 +1 @@ +["€þıœəßð some utf-8 ĸʒ×ŋµåäö𝄞"]
\ No newline at end of file diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/input b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/input new file mode 100644 index 000000000..c598b4172 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/input @@ -0,0 +1 @@ +["\uD834\uDD1E surrogate, four-byte UTF-8"] diff --git a/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/output b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/output new file mode 100644 index 000000000..fa806d254 --- /dev/null +++ b/src/fluent-bit/lib/jansson-e23f558/test/suites/valid/utf-surrogate-four-byte-encoding/output @@ -0,0 +1 @@ +["𝄞 surrogate, four-byte UTF-8"]
\ No newline at end of file |