FGCOM/jansson
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a33c3628da
jansson/test/suites/api/test_pack.c

204 lines
6.9 KiB
C
Raw Normal View History

Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/*
Update copyright notices for 2011
2011-01-21 03:28:54 +08:00
* Copyright (c) 2009-2011 Petri Lehtinen <petri@digip.org>
* Copyright (c) 2010-2011 Graeme Smecher <graeme.smecher@mail.mcgill.ca>
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
*
* 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"
int main()
{
json_t *value;
int i;
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
json_error_t error;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/*
* Simple, valid json_pack cases
*/
/* true */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "b", 1);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_true(value))
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack boolean failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)-1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack boolean refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* false */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "b", 0);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_false(value))
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack boolean failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)-1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack boolean refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* null */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "n");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_null(value))
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack null failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)-1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack null refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* integer */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "i", 1);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_integer(value) || json_integer_value(value) != 1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack integer failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack integer refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* real */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "f", 1.0);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_real(value) || json_real_value(value) != 1.0)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack real failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack real refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* string */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "s", "test");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_string(value) || strcmp("test", json_string_value(value)))
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack string failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack string refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* empty object */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "{}", 1.0);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_object(value) || json_object_size(value) != 0)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack empty object failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack empty object refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* empty list */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "[]", 1.0);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_array(value) || json_array_size(value) != 0)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack empty list failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack empty list failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* non-incref'd object */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "o", json_integer(1));
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_integer(value) || json_integer_value(value) != 1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack object failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack integer refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* incref'd object */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "O", json_integer(1));
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_integer(value) || json_integer_value(value) != 1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack object failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(value->refcount != (ssize_t)2)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack integer refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
json_decref(value);
/* simple object */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "{s:[]}", "foo");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_object(value) || json_object_size(value) != 1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack array failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_array(json_object_get(value, "foo")))
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack array failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(json_object_get(value, "foo")->refcount != (ssize_t)1)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack object refcount failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
json_decref(value);
/* simple array */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "[i,i,i]", 0, 1, 2);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
if(!json_is_array(value) || json_array_size(value) != 3)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack object failed");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
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);
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
/* Whitespace; regular string */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, " s ", "test");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(!json_is_string(value) || strcmp("test", json_string_value(value)))
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack string (with whitespace) failed");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
json_decref(value);
/* Whitespace; empty array */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "[ ]");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(!json_is_array(value) || json_array_size(value) != 0)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack empty array (with whitespace) failed");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
json_decref(value);
/* Whitespace; array */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
value = json_pack_ex(&error, 0, "[ i , i, i ] ", 1, 2, 3);
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(!json_is_array(value) || json_array_size(value) != 3)
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack array (with whitespace) failed");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
json_decref(value);
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/*
* Invalid cases
*/
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/* mismatched open/close array/object */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "[}"))
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
fail("json_pack failed to catch mismatched '}'");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(error.line != 1 || error.column != 2)
fail("json_pack didn't get the error coordinates right!");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "{]"))
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
fail("json_pack failed to catch mismatched ']'");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(error.line != 1 || error.column != 2)
fail("json_pack didn't get the error coordinates right!");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/* missing close array */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "["))
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
fail("json_pack failed to catch missing ']'");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(error.line != 1 || error.column != 2)
fail("json_pack didn't get the error coordinates right!");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/* missing close object */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "{"))
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
fail("json_pack failed to catch missing '}'");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(error.line != 1 || error.column != 2)
fail("json_pack didn't get the error coordinates right!");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
/* NULL string */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "s", NULL))
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
fail("json_pack failed to catch null argument string");
if(error.line != 1 || error.column != 1)
fail("json_pack didn't get the error coordinates right!");
/* NULL format */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, NULL))
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
fail("json_pack failed to catch NULL format string");
Refactor decoder input stream - Add a new field position to the json_error_t structure. This is the position in bytes from the beginning of the input. - Keep track of line, column and input position in the stream level. Previously, only line was tracked, and it was in the lexer level, so this info was not available for UTF-8 decoding errors. - While at it, refactor tests so that no separate "stripped" tests are required. json_process is now able to strip whitespace from its input, and the "valid" and "invalid" test suites now use this to test both non-stripped and stripped input. Closes GH-9.
2011-02-22 16:47:02 +08:00
if(error.line != -1 || error.column != -1)
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
fail("json_pack didn't get the error coordinates right!");
/* More complicated checks for row/columns */
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "{ {}: s }", "foo"))
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
fail("json_pack failed to catch object as key");
if(error.line != 1 || error.column != 3)
fail("json_pack didn't get the error coordinates right!");
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "{ s: {}, s:[ii{} }", "foo", "bar", 12, 13))
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
fail("json_pack failed to catch missing ]");
Refactor json_pack() * Implement a "scanner" that reads the format string, maintaining state * Split json_vnpack() to three separate functions for packing objects, arrays and simple values. This makes it more clear what is being packed, and the object and array structures become more evident. * Make the skipping of ignored character simpler, i.e. skip ':' and ',' independent of their context This patch shaves around 80 lines of code from the original implementation.
2011-01-24 03:14:19 +08:00
if(error.line != 1 || error.column != 19)
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
fail("json_pack didn't get the error coordinates right!");
Expand the pack/unpack API, implement unpack flags Expand the pack/unpack API: json_(un)pack is the simple version with no error output, json_(un)pack_ex has error output and flags, json_v(un)pack_ex is a va_list version of json_(un)pack_ex. Implement unpacking flags: - JSON_UNPACK_ONLY turns off extra validation, i.e. array and object unpacking doesn't check that all items are unpacked. This is really just convenience for not adding '*' after each object and array. - JSON_VALIDATE_ONLY turns off unpacking, i.e. no varargs are expected and nothing is unpacked.
2011-01-25 15:36:43 +08:00
if(json_pack_ex(&error, 0, "[[[[[ [[[[[ [[[[ }]]]] ]]]] ]]]]]"))
Unify style
2011-01-21 03:09:14 +08:00
fail("json_pack failed to catch extra }");
Make json_pack/json_unpack() recursive Note that we pass va_list pointers around instead of just va_lists, which would seem more intuitive. This is necessary since the behaviour of va_lists passed as function parameters is finicky. Quoth stdarg(3): If ap is passed to a function that uses va_arg(ap,type) then the value of ap is undefined after the return of that function. The pointer-passing strategy is used by Python's Py_BuildValue() for the same purpose.
2011-01-15 01:18:42 +08:00
if(error.line != 1 || error.column != 21)
fail("json_pack didn't get the error coordinates right!");
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
Unify style
2011-01-21 03:09:14 +08:00
return 0;
Adds json_pack / json_unpack variadic functions.
2010-10-26 07:36:29 +08:00
}
Reference in New Issue Copy Permalink