mirror of https://github.com/GOSTSec/sgminer
Con Kolivas
11 years ago
242 changed files with 6 additions and 4171 deletions
@ -1,10 +0,0 @@ |
|||||||
SUBDIRS = bin suites |
|
||||||
EXTRA_DIST = scripts run-suites |
|
||||||
|
|
||||||
TESTS = run-suites |
|
||||||
TESTS_ENVIRONMENT = \
|
|
||||||
top_srcdir=$(top_srcdir) \
|
|
||||||
top_builddir=$(top_builddir) |
|
||||||
|
|
||||||
clean-local: |
|
||||||
rm -rf logs |
|
||||||
@ -1,5 +0,0 @@ |
|||||||
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 |
|
||||||
@ -1,349 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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 <config.h> |
|
||||||
#endif |
|
||||||
|
|
||||||
#include <stdio.h> |
|
||||||
#include <stdlib.h> |
|
||||||
#include <string.h> |
|
||||||
#include <ctype.h> |
|
||||||
#include <jansson.h> |
|
||||||
|
|
||||||
#ifdef HAVE_LOCALE_H |
|
||||||
#include <locale.h> |
|
||||||
#endif |
|
||||||
|
|
||||||
#if _WIN32 |
|
||||||
#include <io.h> /* for _setmode() */ |
|
||||||
#include <fcntl.h> /* for _O_BINARY */ |
|
||||||
|
|
||||||
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; |
|
||||||
} 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) |
|
||||||
{ |
|
||||||
long 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); |
|
||||||
line = strtok(buffer, "\r\n"); |
|
||||||
while (line) { |
|
||||||
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, "STRIP")) |
|
||||||
conf.strip = atoi(val); |
|
||||||
|
|
||||||
line = strtok(NULL, "\r\n"); |
|
||||||
} |
|
||||||
|
|
||||||
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 > 255) { |
|
||||||
fprintf(stderr, "invalid value for JSON_INDENT: %d\n", conf.indent); |
|
||||||
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.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; |
|
||||||
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 > 255) { |
|
||||||
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; |
|
||||||
|
|
||||||
if(getenv_int("STRIP")) { |
|
||||||
/* Load to memory, strip leading and trailing whitespace */ |
|
||||||
size_t size = 0, used = 0; |
|
||||||
char *buffer = NULL; |
|
||||||
|
|
||||||
while(1) { |
|
||||||
size_t count; |
|
||||||
|
|
||||||
size = (size == 0 ? 128 : size * 2); |
|
||||||
buffer = realloc(buffer, size); |
|
||||||
if(!buffer) { |
|
||||||
fprintf(stderr, "Unable to allocate %d bytes\n", (int)size); |
|
||||||
return 1; |
|
||||||
} |
|
||||||
|
|
||||||
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; |
|
||||||
} |
|
||||||
@ -1,50 +0,0 @@ |
|||||||
#!/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=$(($passed+1)) |
|
||||||
else |
|
||||||
failed=$(($failed+1)) |
|
||||||
[ $STOP -eq 1 ] && break |
|
||||||
fi |
|
||||||
done |
|
||||||
|
|
||||||
if [ $failed -gt 0 ]; then |
|
||||||
echo "$failed of $((passed+failed)) test suites failed" |
|
||||||
exit 1 |
|
||||||
else |
|
||||||
echo "$passed test suites passed" |
|
||||||
rm -rf $logdir |
|
||||||
fi |
|
||||||
@ -1,100 +0,0 @@ |
|||||||
# Copyright (c) 2009-2013 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 |
|
||||||
@ -1,35 +0,0 @@ |
|||||||
# Copyright (c) 2009-2013 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 |
|
||||||
} |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
SUBDIRS = api |
|
||||||
EXTRA_DIST = invalid invalid-unicode valid |
|
||||||
@ -1,34 +0,0 @@ |
|||||||
EXTRA_DIST = run check-exports |
|
||||||
|
|
||||||
check_PROGRAMS = \
|
|
||||||
test_array \
|
|
||||||
test_copy \
|
|
||||||
test_dump \
|
|
||||||
test_dump_callback \
|
|
||||||
test_equal \
|
|
||||||
test_load \
|
|
||||||
test_loadb \
|
|
||||||
test_load_callback \
|
|
||||||
test_memory_funcs \
|
|
||||||
test_number \
|
|
||||||
test_object \
|
|
||||||
test_pack \
|
|
||||||
test_simple \
|
|
||||||
test_unpack |
|
||||||
|
|
||||||
test_array_SOURCES = test_array.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_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_unpack_SOURCES = test_unpack.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 |
|
||||||
@ -1,23 +0,0 @@ |
|||||||
#!/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_' $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 '^_' | 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 |
|
||||||
@ -1,36 +0,0 @@ |
|||||||
#!/bin/sh |
|
||||||
# |
|
||||||
# Copyright (c) 2009-2013 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 |
|
||||||
@ -1,432 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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.h> |
|
||||||
#include "util.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 begining 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 run_tests() |
|
||||||
{ |
|
||||||
test_misc(); |
|
||||||
test_insert(); |
|
||||||
test_remove(); |
|
||||||
test_clear(); |
|
||||||
test_extend(); |
|
||||||
test_circular(); |
|
||||||
test_array_foreach(); |
|
||||||
} |
|
||||||
@ -1,318 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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 <string.h> |
|
||||||
#include <jansson.h> |
|
||||||
#include "util.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]}"; |
|
||||||
|
|
||||||
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"); |
|
||||||
|
|
||||||
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 modifies its items"); |
|
||||||
|
|
||||||
iter = json_object_iter_next(object, iter); |
|
||||||
} |
|
||||||
|
|
||||||
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]}"; |
|
||||||
|
|
||||||
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"); |
|
||||||
|
|
||||||
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"); |
|
||||||
|
|
||||||
iter = json_object_iter_next(object, iter); |
|
||||||
} |
|
||||||
|
|
||||||
json_decref(object); |
|
||||||
json_decref(copy); |
|
||||||
} |
|
||||||
|
|
||||||
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(); |
|
||||||
} |
|
||||||
@ -1,190 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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.h> |
|
||||||
#include <string.h> |
|
||||||
#include "util.h" |
|
||||||
|
|
||||||
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_dumpf(NULL, stderr, JSON_ENCODE_ANY) != -1) |
|
||||||
fail("json_dumpf didn't fail for NULL"); |
|
||||||
|
|
||||||
/* 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; |
|
||||||
FILE *fp = NULL; |
|
||||||
char *result; |
|
||||||
|
|
||||||
json = json_string("foo"); |
|
||||||
if(json_dumps(json, 0) != NULL) |
|
||||||
fail("json_dumps encoded a string!"); |
|
||||||
if(json_dumpf(json, fp, 0) == 0) |
|
||||||
fail("json_dumpf 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, fp, 0) == 0) |
|
||||||
fail("json_dumpf 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 run_tests() |
|
||||||
{ |
|
||||||
encode_null(); |
|
||||||
encode_twice(); |
|
||||||
circular_references(); |
|
||||||
encode_other_than_array_or_object(); |
|
||||||
escape_slashes(); |
|
||||||
} |
|
||||||
@ -1,81 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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.h> |
|
||||||
#include <string.h> |
|
||||||
#include <stdlib.h> |
|
||||||
#include "util.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); |
|
||||||
} |
|
||||||
@ -1,189 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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.h> |
|
||||||
#include "util.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(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; |
|
||||||
|
|
||||||
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); |
|
||||||
if(!value1 || !value2) |
|
||||||
fail("unable to parse JSON"); |
|
||||||
if(!json_equal(value1, value2)) |
|
||||||
fail("json_equal fails for two inequal strings"); |
|
||||||
|
|
||||||
json_decref(value1); |
|
||||||
json_decref(value2); |
|
||||||
|
|
||||||
/* TODO: There's no negative test case here */ |
|
||||||
} |
|
||||||
|
|
||||||
static void run_tests() |
|
||||||
{ |
|
||||||
test_equal_simple(); |
|
||||||
test_equal_array(); |
|
||||||
test_equal_object(); |
|
||||||
test_equal_complex(); |
|
||||||
} |
|
||||||
@ -1,166 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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.h> |
|
||||||
#include <string.h> |
|
||||||
#include "util.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"); |
|
||||||
} |
|
||||||
|
|
||||||
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("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("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 |
|
||||||
|
|
||||||
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 |
|
||||||
} |
|
||||||
|
|
||||||
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_load_file(NULL, 0, &error); |
|
||||||
if (json) |
|
||||||
fail("json_loadf 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 run_tests() |
|
||||||
{ |
|
||||||
file_not_found(); |
|
||||||
reject_duplicates(); |
|
||||||
disable_eof_check(); |
|
||||||
decode_any(); |
|
||||||
decode_int_as_real(); |
|
||||||
load_wrong_args(); |
|
||||||
position(); |
|
||||||
} |
|
||||||
@ -1,75 +0,0 @@ |
|||||||
/*
|
|
||||||
* 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 <jansson.h> |
|
||||||
#include <string.h> |
|
||||||
#include <stdlib.h> |
|
||||||
#include "util.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"); |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,36 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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.h> |
|
||||||
#include <string.h> |
|
||||||
#include "util.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"); |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,82 +0,0 @@ |
|||||||
#include <string.h> |
|
||||||
#include <jansson.h> |
|
||||||
|
|
||||||
#include "util.h" |
|
||||||
|
|
||||||
static int malloc_called = 0; |
|
||||||
static int free_called = 0; |
|
||||||
|
|
||||||
/* helper */ |
|
||||||
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 *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_set_alloc_funcs(my_malloc, my_free); |
|
||||||
create_and_free_complex_object(); |
|
||||||
|
|
||||||
if(malloc_called != 20 || free_called != 20) |
|
||||||
fail("Custom allocation 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); |
|
||||||
free(ptr); |
|
||||||
} |
|
||||||
|
|
||||||
static void test_secure_funcs(void) |
|
||||||
{ |
|
||||||
json_set_alloc_funcs(secure_malloc, secure_free); |
|
||||||
create_and_free_complex_object(); |
|
||||||
} |
|
||||||
|
|
||||||
static void run_tests() |
|
||||||
{ |
|
||||||
test_simple(); |
|
||||||
test_secure_funcs(); |
|
||||||
} |
|
||||||
@ -1,73 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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 <math.h> |
|
||||||
#include <jansson.h> |
|
||||||
#include "util.h" |
|
||||||
|
|
||||||
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 |
|
||||||
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); |
|
||||||
#endif |
|
||||||
} |
|
||||||
@ -1,511 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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.h> |
|
||||||
#include <string.h> |
|
||||||
#include "util.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 emtpy 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"); |
|
||||||
|
|
||||||
json_decref(nine); |
|
||||||
json_decref(ten); |
|
||||||
json_decref(other); |
|
||||||
json_decref(object); |
|
||||||
} |
|
||||||
|
|
||||||
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); |
|
||||||
|
|
||||||
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_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 || !bar) |
|
||||||
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")) |
|
||||||
fail("iterating failed: wrong key"); |
|
||||||
if(json_object_iter_value(iter) != foo) |
|
||||||
fail("iterating failed: wrong value"); |
|
||||||
|
|
||||||
iter = json_object_iter_next(object, iter); |
|
||||||
if(!iter) |
|
||||||
fail("unable to increment iterator"); |
|
||||||
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"); |
|
||||||
|
|
||||||
iter = json_object_iter_next(object, iter); |
|
||||||
if(!iter) |
|
||||||
fail("unable to increment iterator"); |
|
||||||
if(strcmp(json_object_iter_key(iter), "c")) |
|
||||||
fail("iterating failed: wrong key"); |
|
||||||
if(json_object_iter_value(iter) != baz) |
|
||||||
fail("iterating failed: wrong value"); |
|
||||||
|
|
||||||
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"); |
|
||||||
|
|
||||||
iter = json_object_iter_next(object, iter); |
|
||||||
if(!iter) |
|
||||||
fail("unable to increment iterator"); |
|
||||||
if(strcmp(json_object_iter_key(iter), "c")) |
|
||||||
fail("iterating failed: wrong key"); |
|
||||||
if(json_object_iter_value(iter) != baz) |
|
||||||
fail("iterating failed: wrong value"); |
|
||||||
|
|
||||||
if(json_object_iter_set(object, iter, bar)) |
|
||||||
fail("unable to set value at iterator"); |
|
||||||
|
|
||||||
if(strcmp(json_object_iter_key(iter), "c")) |
|
||||||
fail("json_object_iter_key() fails after json_object_iter_set()"); |
|
||||||
if(json_object_iter_value(iter) != bar) |
|
||||||
fail("json_object_iter_value() fails after json_object_iter_set()"); |
|
||||||
if(json_object_get(object, "c") != bar) |
|
||||||
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_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 run_tests() |
|
||||||
{ |
|
||||||
test_misc(); |
|
||||||
test_clear(); |
|
||||||
test_update(); |
|
||||||
test_conditional_updates(); |
|
||||||
test_circular(); |
|
||||||
test_set_nocheck(); |
|
||||||
test_iterators(); |
|
||||||
test_preserve_order(); |
|
||||||
test_object_foreach(); |
|
||||||
} |
|
||||||
@ -1,283 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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 <config.h> |
|
||||||
#endif |
|
||||||
|
|
||||||
#include <jansson_config.h> |
|
||||||
|
|
||||||
#include <string.h> |
|
||||||
#include <jansson.h> |
|
||||||
#include <stdio.h> |
|
||||||
#include "util.h" |
|
||||||
|
|
||||||
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); |
|
||||||
|
|
||||||
/* string and length */ |
|
||||||
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, 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 failed"); |
|
||||||
if(value->refcount != (size_t)1) |
|
||||||
fail("json_pack string and length refcount failed"); |
|
||||||
json_decref(value); |
|
||||||
|
|
||||||
/* string concatenation */ |
|
||||||
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 */ |
|
||||||
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 failed"); |
|
||||||
if(value->refcount != (size_t)1) |
|
||||||
fail("json_pack string concatenation and length 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); |
|
||||||
|
|
||||||
/* 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); |
|
||||||
|
|
||||||
/* 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); |
|
||||||
|
|
||||||
/* 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); |
|
||||||
|
|
||||||
/* Whitespace; regular string */ |
|
||||||
value = json_pack(" s ", "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("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("Unexpected format character '}'", "<format>", 1, 2, 2); |
|
||||||
|
|
||||||
if(json_pack_ex(&error, 0, "{]")) |
|
||||||
fail("json_pack failed to catch mismatched ']'"); |
|
||||||
check_error("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("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("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("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("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("NULL string argument", "<args>", 1, 1, 1); |
|
||||||
|
|
||||||
/* + on its own */ |
|
||||||
if(json_pack_ex(&error, 0, "+", NULL)) |
|
||||||
fail("json_pack failed to a lone +"); |
|
||||||
check_error("Unexpected format character '+'", "<format>", 1, 1, 1); |
|
||||||
|
|
||||||
/* NULL format */ |
|
||||||
if(json_pack_ex(&error, 0, NULL)) |
|
||||||
fail("json_pack failed to catch NULL format string"); |
|
||||||
check_error("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("NULL string argument", "<args>", 1, 2, 2); |
|
||||||
|
|
||||||
/* 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("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("Unexpected format character '}'", "<format>", 1, 19, 19); |
|
||||||
|
|
||||||
/* Complex array */ |
|
||||||
if(json_pack_ex(&error, 0, "[[[[[ [[[[[ [[[[ }]]]] ]]]] ]]]]]")) |
|
||||||
fail("json_pack failed to catch extra }"); |
|
||||||
check_error("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("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("Invalid UTF-8 string", "<args>", 1, 4, 4); |
|
||||||
} |
|
||||||
@ -1,199 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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 <string.h> |
|
||||||
#include <jansson.h> |
|
||||||
#include "util.h" |
|
||||||
|
|
||||||
/* 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"); |
|
||||||
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_set(value, "bar")) |
|
||||||
fail("json_string_set failed"); |
|
||||||
if(strcmp(json_string_value(value), "bar")) |
|
||||||
fail("invalid string value"); |
|
||||||
|
|
||||||
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_set_nocheck(value, "bar")) |
|
||||||
fail("json_string_set_nocheck failed"); |
|
||||||
if(strcmp(json_string_value(value), "bar")) |
|
||||||
fail("invalid string value"); |
|
||||||
|
|
||||||
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_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"); |
|
||||||
|
|
||||||
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"); |
|
||||||
} |
|
||||||
@ -1,373 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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 <string.h> |
|
||||||
#include <jansson.h> |
|
||||||
#include <stdio.h> |
|
||||||
#include "util.h" |
|
||||||
|
|
||||||
static void run_tests() |
|
||||||
{ |
|
||||||
json_t *j, *j2; |
|
||||||
int i1, i2, i3; |
|
||||||
json_int_t I1; |
|
||||||
int rv; |
|
||||||
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); |
|
||||||
|
|
||||||
/* 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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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}", "foo", "bar", "baz", 42); |
|
||||||
if(!json_unpack_ex(j, &error, 0, "{s:s,s:s!}", "foo", &s, "foo", &s)) |
|
||||||
fail("json_unpack object with strict validation failed"); |
|
||||||
check_error("1 object item(s) left unpacked", "<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("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("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("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("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("1 object item(s) left unpacked", "<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("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); |
|
||||||
} |
|
||||||
@ -1,74 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2013 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 <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:%s:%d: ", __FILE__, __FUNCTION__, __LINE__) |
|
||||||
|
|
||||||
#define fail(msg) \ |
|
||||||
do { \ |
|
||||||
failhdr; \ |
|
||||||
fprintf(stderr, "%s\n", msg); \ |
|
||||||
exit(1); \ |
|
||||||
} while(0) |
|
||||||
|
|
||||||
/* Assumes json_error_t error */ |
|
||||||
#define check_error(text_, source_, line_, column_, position_) \ |
|
||||||
do { \ |
|
||||||
if(strcmp(error.text, text_) != 0) { \ |
|
||||||
failhdr; \ |
|
||||||
fprintf(stderr, "text: \"%s\" != \"%s\"\n", error.text, 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) |
|
||||||
|
|
||||||
|
|
||||||
static void run_tests(); |
|
||||||
|
|
||||||
int main() { |
|
||||||
#ifdef HAVE_SETLOCALE |
|
||||||
setlocale(LC_ALL, ""); |
|
||||||
#endif |
|
||||||
run_tests(); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
#endif |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xed near '"' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 3 3 |
|
||||||
unable to decode byte 0xe5 near '"\' |
|
||||||
@ -1 +0,0 @@ |
|||||||
["\å"] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 1 1 |
|
||||||
unable to decode byte 0xe5 |
|
||||||
@ -1 +0,0 @@ |
|||||||
[å] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 4 4 |
|
||||||
unable to decode byte 0xe5 near '123' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[123å] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 4 4 |
|
||||||
unable to decode byte 0xe5 near '"\u' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 4 4 |
|
||||||
unable to decode byte 0xe5 near '1e1' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[1e1å] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xe5 near 'a' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[a蘊 |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xe5 near '0' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[0å] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 3 3 |
|
||||||
unable to decode byte 0xe5 near '1e' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[1e蘊 |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xe5 near '"' |
|
||||||
@ -1 +0,0 @@ |
|||||||
["å <-- invalid UTF-8"] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 0 0 |
|
||||||
unable to decode byte 0xe5 |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0x81 near '"' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xf4 near '"' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xe0 near '"' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xf0 near '"' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xc1 near '"' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xfd near '"' |
|
||||||
@ -1,27 +0,0 @@ |
|||||||
#!/bin/sh |
|
||||||
# |
|
||||||
# Copyright (c) 2009-2013 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 |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unable to decode byte 0xe0 near '"' |
|
||||||
@ -1 +0,0 @@ |
|||||||
["ŕ˙ <-- truncated UTF-8"] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
invalid token near ''' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 1 1 |
|
||||||
'[' or '{' expected near 'a' |
|
||||||
@ -1 +0,0 @@ |
|||||||
aå |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
string or '}' expected near ',' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
unexpected token near ',' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
2 0 4 |
|
||||||
']' expected near end of file |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 3 3 |
|
||||||
']' expected near end of file |
|
||||||
@ -1 +0,0 @@ |
|||||||
[1, |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 0 0 |
|
||||||
'[' or '{' expected near end of file |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 33 33 |
|
||||||
\u0000 is not allowed |
|
||||||
@ -1 +0,0 @@ |
|||||||
["\u0000 (null byte not allowed)"] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 4 4 |
|
||||||
unexpected token near ']' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[1,] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
6 1 17 |
|
||||||
unexpected token near ']' |
|
||||||
@ -1,6 +0,0 @@ |
|||||||
[1, |
|
||||||
2, |
|
||||||
3, |
|
||||||
4, |
|
||||||
5, |
|
||||||
] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
2 3 11 |
|
||||||
end of file expected near 'foo' |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
[1,2,3] |
|
||||||
foo |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 10 10 |
|
||||||
end of file expected near 'foo' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[1,2,3]foo |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 2 2 |
|
||||||
invalid token near '0' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[012] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 4 4 |
|
||||||
invalid escape near '"\a' |
|
||||||
@ -1 +0,0 @@ |
|||||||
["\a <-- invalid escape"] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 5 5 |
|
||||||
invalid token near 'troo' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[troo |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 8 8 |
|
||||||
']' expected near 'foo' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[-123foo] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 12 12 |
|
||||||
']' expected near 'foo' |
|
||||||
@ -1 +0,0 @@ |
|||||||
[-123.123foo] |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
1 62 62 |
|
||||||
invalid Unicode '\uD888\u3210' |
|
||||||
@ -1 +0,0 @@ |
|||||||
["\uD888\u3210 (first surrogate and invalid second surrogate)"] |
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue