[pulseaudio-discuss] [PATCH 1/2] pulse: Add a JSON-parsing library
Arun Raghavan
arun at accosted.net
Mon May 2 04:52:39 UTC 2016
On 26 April 2016 at 17:47, <arun at accosted.net> wrote:
> From: Arun Raghavan <git at arunraghavan.net>
>
> Adding this to be able to drop dependency on json-c.
>
> Fixes: https://bugs.freedesktop.org/show_bug.cgi?id=95135
> ---
> src/Makefile.am | 8 +
> src/pulse/json.c | 476 ++++++++++++++++++++++++++++++++++++++++++++++++++
> src/pulse/json.h | 57 ++++++
> src/tests/json-test.c | 240 +++++++++++++++++++++++++
> 4 files changed, 781 insertions(+)
> create mode 100644 src/pulse/json.c
> create mode 100644 src/pulse/json.h
> create mode 100644 src/tests/json-test.c
>
> diff --git a/src/Makefile.am b/src/Makefile.am
> index b600dfb..9d952fc 100644
> --- a/src/Makefile.am
> +++ b/src/Makefile.am
> @@ -248,6 +248,7 @@ TESTS_default = \
> thread-mainloop-test \
> utf8-test \
> format-test \
> + json-test \
> get-binary-name-test \
> hook-list-test \
> memblock-test \
> @@ -375,6 +376,12 @@ format_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
> format_test_LDADD = $(AM_LDADD) libpulsecore- at PA_MAJORMINOR@.la libpulse.la libpulsecommon- at PA_MAJORMINOR@.la
> format_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>
> +json_test_SOURCES = tests/json-test.c
> +json_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
> +json_test_LDADD = $(AM_LDADD) libpulse.la libpulsecommon- at PA_MAJORMINOR@.la
> +json_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
> +
> +srbchannel_test_SOURCES = tests/srbchannel-test.c
> srbchannel_test_SOURCES = tests/srbchannel-test.c
> srbchannel_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
> srbchannel_test_LDADD = $(AM_LDADD) libpulse.la libpulsecommon- at PA_MAJORMINOR@.la
> @@ -646,6 +653,7 @@ libpulsecommon_ at PA_MAJORMINOR@_la_SOURCES = \
> pulse/client-conf.c pulse/client-conf.h \
> pulse/fork-detect.c pulse/fork-detect.h \
> pulse/format.c pulse/format.h \
> + pulse/json.c pulse/json.h \
> pulse/xmalloc.c pulse/xmalloc.h \
> pulse/proplist.c pulse/proplist.h \
> pulse/utf8.c pulse/utf8.h \
> diff --git a/src/pulse/json.c b/src/pulse/json.c
> new file mode 100644
> index 0000000..0e53902
> --- /dev/null
> +++ b/src/pulse/json.c
> @@ -0,0 +1,476 @@
> +/***
> + This file is part of PulseAudio.
> +
> + Copyright 2016 Arun Raghavan <mail at arunraghavan.net>
> +
> + PulseAudio is free software; you can redistribute it and/or modify
> + it under the terms of the GNU Lesser General Public License as published
> + by the Free Software Foundation; either version 2.1 of the License,
> + or (at your option) any later version.
> +
> + PulseAudio is distributed in the hope that it will be useful, but
> + WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public License
> + along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
> +***/
> +
> +#include <math.h>
> +
> +#include <pulse/json.h>
> +#include <pulse/xmalloc.h>
> +#include <pulsecore/refcnt.h>
> +#include <pulsecore/strbuf.h>
> +
> +struct pa_json_object {
> + PA_REFCNT_DECLARE;
> + pa_json_type type;
> +
> + union {
> + int int_value;
> + double double_value;
> + bool bool_value;
> + char *string_value;
> + pa_hashmap *object_values; /* name -> object */
> + pa_idxset *array_values; /* objects */
> + };
> +};
> +
> +#define JSON_OBJECT_TYPE(o) ((o)->type)
> +
> +static const char* parse_value(const char *str, const char *end, pa_json_object **obj);
> +
> +static pa_json_object* json_object_new(void) {
> + pa_json_object *obj;
> +
> + obj = pa_xnew0(pa_json_object, 1);
> +
> + return obj;
> +}
> +
> +static bool is_whitespace(char c) {
> + return c == '\t' || c == '\f' || c == '\r' || c == ' ';
Small bug here. This should be '\n' not '\f'. Fixing that locally.
-- Arun
> +}
> +
> +static bool is_digit(char c) {
> + return c >= '0' && c <= '9';
> +}
> +
> +static bool is_end(const char c, const char *end) {
> + if (!end)
> + return c == '\0';
> + else {
> + while (*end) {
> + if (c == *end)
> + return true;
> + end++;
> + }
> + }
> +
> + return false;
> +}
> +
> +static const char* consume_string(const char *str, const char *expect)
> +{
> + while (*expect) {
> + if (*str != *expect)
> + return NULL;
> +
> + str++;
> + expect++;
> + }
> +
> + return str;
> +}
> +
> +static const char* parse_null(const char *str, pa_json_object *obj) {
> + str = consume_string(str, "null");
> +
> + if (str)
> + obj->type = PA_JSON_TYPE_NULL;
> +
> + return str;
> +}
> +
> +static const char* parse_boolean(const char *str, pa_json_object *obj) {
> + const char *tmp;
> +
> + tmp = consume_string(str, "true");
> +
> + if (tmp) {
> + obj->type = PA_JSON_TYPE_BOOL;
> + obj->bool_value = true;
> + } else {
> + tmp = consume_string(str, "false");
> +
> + if (str) {
> + obj->type = PA_JSON_TYPE_BOOL;
> + obj->bool_value = false;
> + }
> + }
> +
> + return tmp;
> +}
> +
> +static const char* parse_string(const char *str, pa_json_object *obj) {
> + pa_strbuf *buf = pa_strbuf_new();
> +
> + str++; /* Consume leading '"' */
> +
> + while (*str != '"') {
> + if (*str != '\\') {
> + /* Normal character, juts consume */
> + pa_strbuf_putc(buf, *str);
> + } else {
> + /* Need to unescape */
> + str++;
> +
> + switch (*str) {
> + case '"':
> + case '\\':
> + case '/':
> + pa_strbuf_putc(buf, *str);
> + break;
> +
> + case 'b':
> + pa_strbuf_putc(buf, '\b' /* backspace */);
> + break;
> +
> + case 'f':
> + pa_strbuf_putc(buf, '\f' /* form feed */);
> + break;
> +
> + case 'n':
> + pa_strbuf_putc(buf, '\n' /* new line */);
> + break;
> +
> + case 'r':
> + pa_strbuf_putc(buf, '\r' /* carriage return */);
> + break;
> +
> + case 't':
> + pa_strbuf_putc(buf, '\t' /* horizontal tab */);
> + break;
> +
> + case 'u':
> + pa_log("Unicode code points are currently unsupported");
> + goto error;
> +
> + default:
> + pa_log("Unexepcted escape value: %c", *str);
> + goto error;
> + }
> + }
> +
> + str++;
> + }
> +
> + if (*str != '"') {
> + pa_log("Failed to parse remainder of string: %s", str);
> + goto error;
> + }
> +
> + str++;
> +
> + obj->type = PA_JSON_TYPE_STRING;
> + obj->string_value = pa_strbuf_to_string_free(buf);
> +
> + return str;
> +
> +error:
> + pa_strbuf_free(buf);
> + return NULL;
> +}
> +
> +static const char* parse_number(const char *str, pa_json_object *obj) {
> + bool negative = false, has_fraction = false, has_exponent = false;
> + unsigned int integer = 0;
> + unsigned int fraction = 0;
> + unsigned int fraction_digits = 0;
> + int exponent = 0;
> +
> + if (*str == '-') {
> + negative = true;
> + str++;
> + }
> +
> + if (*str == '0') {
> + str++;
> + goto fraction;
> + }
> +
> + while (is_digit(*str)) {
> + integer = (integer * 10) + (*str - '0');
> + str++;
> + }
> +
> +fraction:
> + if (*str == '.') {
> + has_fraction = true;
> + str++;
> +
> + while (is_digit(*str)) {
> + fraction = (fraction * 10) + (*str - '0');
> + fraction_digits++;
> + str++;
> + }
> + }
> +
> + if (*str == 'e' || *str == 'E') {
> + bool exponent_negative = false;
> +
> + has_exponent = true;
> + str++;
> +
> + if (*str == '-') {
> + exponent_negative = true;
> + str++;
> + } else if (*str == '+')
> + str++;
> +
> + while (is_digit(*str)) {
> + exponent = (exponent * 10) + (*str - '0');
> + str++;
> + }
> +
> + if (exponent_negative)
> + exponent *= -1;
> + }
> +
> + if (has_fraction || has_exponent) {
> + obj->type = PA_JSON_TYPE_DOUBLE;
> + obj->double_value =
> + (negative ? -1.0 : 1.0) * (integer + (double) fraction / pow(10, fraction_digits)) * pow(10, exponent);
> + } else {
> + obj->type = PA_JSON_TYPE_INT;
> + obj->int_value = (negative ? -1 : 1) * integer;
> + }
> +
> + return str;
> +}
> +
> +static const char *parse_object(const char *str, pa_json_object *obj) {
> + pa_json_object *name, *value;
> +
> + obj->object_values = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func,
> + pa_xfree, (pa_free_cb_t) pa_json_object_unref);
> +
> + while (*str != '}') {
> + str++; /* Consume leading '{' or ',' */
> +
> + str = parse_value(str, ":", &name);
> + if (!str || JSON_OBJECT_TYPE(name) != PA_JSON_TYPE_STRING) {
> + pa_log("Could not parse key for object: %s", str);
> + goto error;
> + }
> +
> + /* Consume the ':' */
> + str++;
> +
> + str = parse_value(str, ",}", &value);
> + if (!str) {
> + pa_log("Could not parse value for object: %s", str);
> + goto error;
> + }
> +
> + pa_hashmap_put(obj->object_values, pa_xstrdup(pa_json_object_get_string(name)), value);
> + pa_json_object_unref(name);
> + }
> +
> + /* Drop trailing '}' */
> + str++;
> +
> + /* We now know the value was correctly parsed */
> + obj->type = PA_JSON_TYPE_OBJECT;
> +
> + return str;
> +
> +error:
> + pa_hashmap_free(obj->object_values);
> + return NULL;
> +}
> +
> +static const char *parse_array(const char *str, pa_json_object *obj) {
> + pa_json_object *value;
> +
> + obj->array_values = pa_idxset_new(NULL, NULL);
> +
> + while (*str != ']') {
> + str++; /* Consume leading '[' or ',' */
> +
> + /* Need to chew up whitespaces as a special case to deal with the
> + * possibility of an empty array */
> + while (is_whitespace(*str))
> + str++;
> +
> + if (*str == ']')
> + break;
> +
> + str = parse_value(str, ",]", &value);
> + if (!str) {
> + pa_log("Could not parse value for array: %s", str);
> + goto error;
> + }
> +
> + pa_idxset_put(obj->array_values, value, NULL);
> + }
> +
> + /* Drop trailing ']' */
> + str++;
> +
> + /* We now know the value was correctly parsed */
> + obj->type = PA_JSON_TYPE_ARRAY;
> +
> + return str;
> +
> +error:
> + pa_idxset_free(obj->array_values, (pa_free_cb_t) pa_json_object_unref);
> + return NULL;
> +}
> +
> +typedef enum {
> + JSON_PARSER_STATE_INIT,
> + JSON_PARSER_STATE_FINISH,
> +} json_parser_state;
> +
> +static const char* parse_value(const char *str, const char *end, pa_json_object **obj) {
> + json_parser_state state = JSON_PARSER_STATE_INIT;
> +
> + pa_return_val_if_fail(str != NULL, NULL);
> +
> + *obj = json_object_new();
> +
> + while (!is_end(*str, end)) {
> + switch (state) {
> + case JSON_PARSER_STATE_INIT:
> + if (is_whitespace(*str)) {
> + str++;
> + } else if (*str == 'n') {
> + str = parse_null(str, *obj);
> + state = JSON_PARSER_STATE_FINISH;
> + } else if (*str == 't' || *str == 'f') {
> + str = parse_boolean(str, *obj);
> + state = JSON_PARSER_STATE_FINISH;
> + } else if (*str == '"') {
> + str = parse_string(str, *obj);
> + state = JSON_PARSER_STATE_FINISH;
> + } else if (is_digit(*str) || *str == '-') {
> + str = parse_number(str, *obj);
> + state = JSON_PARSER_STATE_FINISH;
> + } else if (*str == '{') {
> + str = parse_object(str, *obj);
> + state = JSON_PARSER_STATE_FINISH;
> + } else if (*str == '[') {
> + str = parse_array(str, *obj);
> + state = JSON_PARSER_STATE_FINISH;
> + }
> +
> + if (!str)
> + goto error;
> +
> + break;
> +
> + case JSON_PARSER_STATE_FINISH:
> + /* Consume trailing whitespaces */
> + if (is_whitespace(*str)) {
> + str++;
> + } else {
> + goto error;
> + }
> + }
> + }
> +
> + if (JSON_OBJECT_TYPE(*obj) == PA_JSON_TYPE_INIT) {
> + /* We didn't actually get any data */
> + pa_log("No data while parsing json string: '%s' till '%s'", str, end);
> + goto error;
> + }
> +
> + return str;
> +
> +error:
> + pa_json_object_unref(*obj);
> + return NULL;
> +}
> +
> +
> +pa_json_object* pa_json_parse(const char *str) {
> + pa_json_object *obj;
> +
> + str = parse_value(str, NULL, &obj);
> + pa_assert(*str == '\0');
> +
> + return obj;
> +}
> +
> +pa_json_type pa_json_object_get_type(const pa_json_object *obj) {
> + return JSON_OBJECT_TYPE(obj);
> +}
> +
> +void pa_json_object_unref(pa_json_object *obj) {
> + if (PA_REFCNT_DEC(obj) > 0)
> + return;
> +
> + switch (JSON_OBJECT_TYPE(obj)) {
> + case PA_JSON_TYPE_INIT:
> + case PA_JSON_TYPE_INT:
> + case PA_JSON_TYPE_DOUBLE:
> + case PA_JSON_TYPE_BOOL:
> + case PA_JSON_TYPE_NULL:
> + break;
> +
> + case PA_JSON_TYPE_STRING:
> + pa_xfree(obj->string_value);
> + break;
> +
> + case PA_JSON_TYPE_OBJECT:
> + pa_hashmap_free(obj->object_values);
> + break;
> +
> + case PA_JSON_TYPE_ARRAY:
> + pa_idxset_free(obj->array_values, (pa_free_cb_t) pa_json_object_unref);
> + break;
> +
> + default:
> + pa_assert_not_reached();
> + }
> +
> + pa_xfree(obj);
> +}
> +
> +int pa_json_object_get_int(const pa_json_object *o) {
> + pa_return_val_if_fail(JSON_OBJECT_TYPE(o) == PA_JSON_TYPE_INT, 0);
> + return o->int_value;
> +}
> +
> +double pa_json_object_get_double(const pa_json_object *o) {
> + pa_return_val_if_fail(JSON_OBJECT_TYPE(o) == PA_JSON_TYPE_DOUBLE, 0);
> + return o->double_value;
> +}
> +
> +bool pa_json_object_get_bool(const pa_json_object *o) {
> + pa_return_val_if_fail(JSON_OBJECT_TYPE(o) == PA_JSON_TYPE_BOOL, false);
> + return o->bool_value;
> +}
> +
> +const char* pa_json_object_get_string(const pa_json_object *o) {
> + pa_return_val_if_fail(JSON_OBJECT_TYPE(o) == PA_JSON_TYPE_STRING, NULL);
> + return o->string_value;
> +}
> +
> +const pa_json_object* pa_json_object_get_object_member(const pa_json_object *o, const char *name) {
> + pa_return_val_if_fail(JSON_OBJECT_TYPE(o) == PA_JSON_TYPE_OBJECT, NULL);
> + return pa_hashmap_get(o->object_values, name);
> +}
> +
> +int pa_json_object_get_array_length(const pa_json_object *o) {
> + pa_return_val_if_fail(JSON_OBJECT_TYPE(o) == PA_JSON_TYPE_ARRAY, 0);
> + return pa_idxset_size(o->array_values);
> +}
> +
> +const pa_json_object* pa_json_object_get_array_member(const pa_json_object *o, int index) {
> + pa_return_val_if_fail(JSON_OBJECT_TYPE(o) == PA_JSON_TYPE_ARRAY, NULL);
> + return pa_idxset_get_by_index(o->array_values, index);
> +}
> diff --git a/src/pulse/json.h b/src/pulse/json.h
> new file mode 100644
> index 0000000..6eba9a9
> --- /dev/null
> +++ b/src/pulse/json.h
> @@ -0,0 +1,57 @@
> +/***
> + This file is part of PulseAudio.
> +
> + Copyright 2016 Arun Raghavan <mail at arunraghavan.net>
> +
> + PulseAudio is free software; you can redistribute it and/or modify
> + it under the terms of the GNU Lesser General Public License as published
> + by the Free Software Foundation; either version 2.1 of the License,
> + or (at your option) any later version.
> +
> + PulseAudio is distributed in the hope that it will be useful, but
> + WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public License
> + along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
> +***/
> +
> +#ifdef HAVE_CONFIG_H
> +#include <config.h>
> +#endif
> +
> +#include <pulsecore/hashmap.h>
> +
> +PA_C_DECL_BEGIN
> +
> +typedef enum {
> + PA_JSON_TYPE_INIT = 0,
> + PA_JSON_TYPE_NULL,
> + PA_JSON_TYPE_INT,
> + PA_JSON_TYPE_DOUBLE,
> + PA_JSON_TYPE_BOOL,
> + PA_JSON_TYPE_STRING,
> + PA_JSON_TYPE_ARRAY,
> + PA_JSON_TYPE_OBJECT,
> +} pa_json_type;
> +
> +typedef struct pa_json_object pa_json_object;
> +
> +pa_json_object* pa_json_parse(const char *str);
> +pa_json_type pa_json_object_get_type(const pa_json_object *obj);
> +void pa_json_object_unref(pa_json_object *obj);
> +
> +/* All pointer members that are returned are valid while the corresponding object is valid */
> +
> +int pa_json_object_get_int(const pa_json_object *o);
> +double pa_json_object_get_double(const pa_json_object *o);
> +bool pa_json_object_get_bool(const pa_json_object *o);
> +const char* pa_json_object_get_string(const pa_json_object *o);
> +
> +const pa_json_object* pa_json_object_get_object_member(const pa_json_object *o, const char *name);
> +
> +int pa_json_object_get_array_length(const pa_json_object *o);
> +const pa_json_object* pa_json_object_get_array_member(const pa_json_object *o, int index);
> +
> +PA_C_DECL_END
> diff --git a/src/tests/json-test.c b/src/tests/json-test.c
> new file mode 100644
> index 0000000..9be4dac
> --- /dev/null
> +++ b/src/tests/json-test.c
> @@ -0,0 +1,240 @@
> +/***
> + This file is part of PulseAudio.
> +
> + Copyright 2016 Arun Raghavan <mail at arunraghavan.net>
> +
> + PulseAudio is free software; you can redistribute it and/or modify
> + it under the terms of the GNU Lesser General Public License as published
> + by the Free Software Foundation; either version 2.1 of the License,
> + or (at your option) any later version.
> +
> + PulseAudio is distributed in the hope that it will be useful, but
> + WITHOUT ANY WARRANTY; without even the implied warranty of
> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + General Public License for more details.
> +
> + You should have received a copy of the GNU Lesser General Public License
> + along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
> +***/
> +
> +#include <check.h>
> +
> +#include <pulse/json.h>
> +#include <pulsecore/core-util.h>
> +
> +#define IS_EQUAL(x, y) (((x) - (y)) < 0.000001 && ((x) - (y)) > -0.000001)
> +
> +START_TEST (string_test) {
> + pa_json_object *o;
> + unsigned int i;
> + const char *strings_parse[] = {
> + "\"\"", "\"test\"", "\"test123\"", "\"123\"", "\"newline\n\"", "\" spaces \"",
> + " \"lots of spaces\" ", "\"esc\\nape\"", "\"escape a \\\" quote\"",
> + };
> + const char *strings_compare[] = {
> + "", "test", "test123", "123", "newline\n", " spaces ",
> + "lots of spaces", "esc\nape", "escape a \" quote",
> + };
> +
> + for (i = 0; i < PA_ELEMENTSOF(strings_parse); i++) {
> + o = pa_json_parse(strings_parse[i]);
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_STRING);
> + fail_unless(pa_streq(pa_json_object_get_string(o), strings_compare[i]));
> +
> + pa_json_object_unref(o);
> + }
> +}
> +END_TEST
> +
> +START_TEST(int_test) {
> + pa_json_object *o;
> + unsigned int i;
> + const char *ints_parse[] = { "1", "-1", "1234", "0" };
> + const int ints_compare[] = { 1, -1, 1234, 0 };
> +
> + for (i = 0; i < PA_ELEMENTSOF(ints_parse); i++) {
> + o = pa_json_parse(ints_parse[i]);
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_INT);
> + fail_unless(pa_json_object_get_int(o) == ints_compare[i]);
> +
> + pa_json_object_unref(o);
> + }
> +}
> +END_TEST
> +
> +START_TEST(double_test) {
> + pa_json_object *o;
> + unsigned int i;
> + const char *doubles_parse[] = {
> + "1.0", "-1.1", "1234e2", "1234e0", "0.1234", "-0.1234", "1234e-1", "1234.5e-1", "1234.5e+2",
> + };
> + const double doubles_compare[] = {
> + 1.0, -1.1, 123400.0, 1234.0, 0.1234, -0.1234, 123.4, 123.45, 123450.0,
> + };
> +
> + for (i = 0; i < PA_ELEMENTSOF(doubles_parse); i++) {
> + o = pa_json_parse(doubles_parse[i]);
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_DOUBLE);
> + fail_unless(IS_EQUAL(pa_json_object_get_double(o), doubles_compare[i]));
> +
> + pa_json_object_unref(o);
> + }
> +}
> +END_TEST
> +
> +START_TEST(null_test) {
> + pa_json_object *o;
> +
> + o = pa_json_parse("null");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_NULL);
> +
> + pa_json_object_unref(o);
> +}
> +END_TEST
> +
> +START_TEST(bool_test) {
> + pa_json_object *o;
> +
> + o = pa_json_parse("true");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_BOOL);
> + fail_unless(pa_json_object_get_bool(o) == true);
> +
> + pa_json_object_unref(o);
> +
> + o = pa_json_parse("false");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_BOOL);
> + fail_unless(pa_json_object_get_bool(o) == false);
> +
> + pa_json_object_unref(o);
> +}
> +END_TEST
> +
> +START_TEST(object_test) {
> + pa_json_object *o;
> + const pa_json_object *v;
> +
> + o = pa_json_parse(" { \"name\" : \"A Person\" } ");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_OBJECT);
> +
> + v = pa_json_object_get_object_member(o, "name");
> + fail_unless(v != NULL);
> + fail_unless(pa_json_object_get_type(v) == PA_JSON_TYPE_STRING);
> + fail_unless(pa_streq(pa_json_object_get_string(v), "A Person"));
> +
> + pa_json_object_unref(o);
> +
> + o = pa_json_parse(" { \"age\" : -45.3e-0 } ");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_OBJECT);
> +
> + v = pa_json_object_get_object_member(o, "age");
> + fail_unless(v != NULL);
> + fail_unless(pa_json_object_get_type(v) == PA_JSON_TYPE_DOUBLE);
> + fail_unless(IS_EQUAL(pa_json_object_get_double(v), -45.3));
> +
> + pa_json_object_unref(o);
> +
> + o = pa_json_parse("{\"person\":true}");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_OBJECT);
> +
> + v = pa_json_object_get_object_member(o, "person");
> + fail_unless(v != NULL);
> + fail_unless(pa_json_object_get_type(v) == PA_JSON_TYPE_BOOL);
> + fail_unless(IS_EQUAL(pa_json_object_get_bool(v), true));
> +
> + pa_json_object_unref(o);
> +}
> +END_TEST
> +
> +START_TEST(array_test) {
> + pa_json_object *o;
> + const pa_json_object *v, *v2;
> +
> + o = pa_json_parse(" [ ] ");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_ARRAY);
> + fail_unless(pa_json_object_get_array_length(o) == 0);
> +
> + pa_json_object_unref(o);
> +
> + o = pa_json_parse("[\"a member\"]");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_ARRAY);
> + fail_unless(pa_json_object_get_array_length(o) == 1);
> +
> + v = pa_json_object_get_array_member(o, 0);
> + fail_unless(v != NULL);
> + fail_unless(pa_json_object_get_type(v) == PA_JSON_TYPE_STRING);
> + fail_unless(pa_streq(pa_json_object_get_string(v), "a member"));
> +
> + pa_json_object_unref(o);
> +
> + o = pa_json_parse("[\"a member\", 1234.5, { \"another\": true } ]");
> +
> + fail_unless(o != NULL);
> + fail_unless(pa_json_object_get_type(o) == PA_JSON_TYPE_ARRAY);
> + fail_unless(pa_json_object_get_array_length(o) == 3);
> +
> + v = pa_json_object_get_array_member(o, 0);
> + fail_unless(v != NULL);
> + fail_unless(pa_json_object_get_type(v) == PA_JSON_TYPE_STRING);
> + fail_unless(pa_streq(pa_json_object_get_string(v), "a member"));
> + v = pa_json_object_get_array_member(o, 1);
> + fail_unless(v != NULL);
> + fail_unless(pa_json_object_get_type(v) == PA_JSON_TYPE_DOUBLE);
> + fail_unless(IS_EQUAL(pa_json_object_get_double(v), 1234.5));
> + v = pa_json_object_get_array_member(o, 2);
> + fail_unless(v != NULL);
> + fail_unless(pa_json_object_get_type(v) == PA_JSON_TYPE_OBJECT);
> + v2 =pa_json_object_get_object_member(v, "another");
> + fail_unless(v2 != NULL);
> + fail_unless(pa_json_object_get_type(v2) == PA_JSON_TYPE_BOOL);
> + fail_unless(pa_json_object_get_bool(v2) == true);
> +
> + pa_json_object_unref(o);
> +}
> +END_TEST
> +
> +int main(int argc, char *argv[]) {
> + int failed = 0;
> + Suite *s;
> + TCase *tc;
> + SRunner *sr;
> +
> + s = suite_create("JSON");
> + tc = tcase_create("json");
> + tcase_add_test(tc, string_test);
> + tcase_add_test(tc, int_test);
> + tcase_add_test(tc, double_test);
> + tcase_add_test(tc, null_test);
> + tcase_add_test(tc, bool_test);
> + tcase_add_test(tc, object_test);
> + tcase_add_test(tc, array_test);
> + suite_add_tcase(s, tc);
> +
> + sr = srunner_create(s);
> + srunner_run_all(sr, CK_NORMAL);
> + failed = srunner_ntests_failed(sr);
> + srunner_free(sr);
> +
> + return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
> +}
> --
> 2.5.5
>
More information about the pulseaudio-discuss
mailing list