Merged revisions 378915,378918 via svnmerge from
authorAutomerge script <automerge@asterisk.org>
Fri, 11 Jan 2013 23:20:57 +0000 (23:20 +0000)
committerAutomerge script <automerge@asterisk.org>
Fri, 11 Jan 2013 23:20:57 +0000 (23:20 +0000)
file:///srv/subversion/repos/asterisk/trunk

................
  r378915 | dlee | 2013-01-11 16:31:42 -0600 (Fri, 11 Jan 2013) | 21 lines

  Add JSON API for Asterisk.

  This provides a JSON API by pulling in and wrapping the Jansson JSON
  library[1]. The Asterisk API basically mirrors the Jansson
  functionality, with a few minor tweaks.

   * Some names have been asteriskified to protect the innocent.
   * Jansson provides both reference-stealing and reference-borrowing
     versions of several API's. The Asterisk API is exclusively
     reference-stealing for operations that put elements into arrays and
     objects.
   * No support for doubles, since we usually don't need that.
   * Coming along for the ride is the ast_test_validate macro, which made
     the unit tests much easier to write.

   [1]: http://www.digip.org/jansson/

  (issue ASTERISK-20887)
  (closes issue ASTERISK-20888)
  Review: https://reviewboard.asterisk.org/r/2264/
................
  r378918 | file | 2013-01-11 17:05:38 -0600 (Fri, 11 Jan 2013) | 11 lines

  Retain XMPP filters across reconnections so external modules continue to function as expected.

  Previously if an XMPP client reconnected any filters added by an external module were lost.
  This issue exhibited itself with chan_motif not receiving and reacting to Jingle signaling.

  (closes issue ASTERISK-20916)
  Reported by: kuj
  ........

  Merged revisions 378917 from http://svn.asterisk.org/svn/asterisk/branches/11
................

git-svn-id: https://origsvn.digium.com/svn/asterisk/team/mmichelson/threadpool@378927 65c4cc65-6c06-0410-ace0-fbb531ad65f3

13 files changed:
build_tools/menuselect-deps.in
configure
configure.ac
contrib/scripts/install_prereq
include/asterisk/autoconfig.h.in
include/asterisk/json.h [new file with mode: 0644]
include/asterisk/test.h
main/Makefile
makeopts.in
res/res_json.c [new file with mode: 0644]
res/res_json.exports.in [new file with mode: 0644]
res/res_xmpp.c
tests/test_json.c [new file with mode: 0644]

index 6f4418b..b3bcf95 100644 (file)
@@ -25,6 +25,7 @@ IODBC=@PBX_IODBC@
 ISDNNET=@PBX_ISDNNET@
 IXJUSER=@PBX_IXJUSER@
 JACK=@PBX_JACK@
+JANSSON=@PBX_JANSSON@
 KQUEUE=@PBX_KQUEUE@
 LDAP=@PBX_LDAP@
 LIBEDIT=@PBX_LIBEDIT@
index 44bb31d..edbf19c 100755 (executable)
--- a/configure
+++ b/configure
@@ -1,5 +1,5 @@
 #! /bin/sh
-# From configure.ac Revision: 377977 .
+# From configure.ac Revision: 377981 .
 # Guess values for system-dependent variables and create Makefiles.
 # Generated by GNU Autoconf 2.69 for asterisk trunk.
 #
@@ -974,6 +974,10 @@ PBX_KQUEUE
 KQUEUE_DIR
 KQUEUE_INCLUDE
 KQUEUE_LIB
+PBX_JANSSON
+JANSSON_DIR
+JANSSON_INCLUDE
+JANSSON_LIB
 PBX_JACK
 JACK_DIR
 JACK_INCLUDE
@@ -1245,6 +1249,7 @@ with_inotify
 with_iodbc
 with_isdnnet
 with_jack
+with_jansson
 with_kqueue
 with_ldap
 with_libcurl
@@ -1972,6 +1977,7 @@ Optional Packages:
   --with-iodbc=PATH       use iODBC files in PATH
   --with-isdnnet=PATH     use ISDN4Linux files in PATH
   --with-jack=PATH        use Jack Audio Connection Kit files in PATH
+  --with-jansson=PATH     use Jansson JSON library files in PATH
   --with-kqueue=PATH      use kqueue support files in PATH
   --with-ldap=PATH        use OpenLDAP files in PATH
   --with-libcurl=DIR      look for the curl library in DIR
@@ -8911,6 +8917,38 @@ fi
 
 
 
+    JANSSON_DESCRIP="Jansson JSON library"
+    JANSSON_OPTION="jansson"
+    PBX_JANSSON=0
+
+# Check whether --with-jansson was given.
+if test "${with_jansson+set}" = set; then :
+  withval=$with_jansson;
+       case ${withval} in
+       n|no)
+       USE_JANSSON=no
+       # -1 is a magic value used by menuselect to know that the package
+       # was disabled, other than 'not found'
+       PBX_JANSSON=-1
+       ;;
+       y|ye|yes)
+       ac_mandatory_list="${ac_mandatory_list} JANSSON"
+       ;;
+       *)
+       JANSSON_DIR="${withval}"
+       ac_mandatory_list="${ac_mandatory_list} JANSSON"
+       ;;
+       esac
+
+fi
+
+
+
+
+
+
+
+
     KQUEUE_DESCRIP="kqueue support"
     KQUEUE_OPTION="kqueue"
     PBX_KQUEUE=0
 
 
 
+
+if test "x${PBX_JANSSON}" != "x1" -a "${USE_JANSSON}" != "no"; then
+   pbxlibdir=""
+   # if --with-JANSSON=DIR has been specified, use it.
+   if test "x${JANSSON_DIR}" != "x"; then
+      if test -d ${JANSSON_DIR}/lib; then
+        pbxlibdir="-L${JANSSON_DIR}/lib"
+      else
+        pbxlibdir="-L${JANSSON_DIR}"
+      fi
+   fi
+   pbxfuncname="json_dumps"
+   if test "x${pbxfuncname}" = "x" ; then   # empty lib, assume only headers
+      AST_JANSSON_FOUND=yes
+   else
+      ast_ext_lib_check_save_CFLAGS="${CFLAGS}"
+      CFLAGS="${CFLAGS} "
+      as_ac_Lib=`$as_echo "ac_cv_lib_jansson_${pbxfuncname}" | $as_tr_sh`
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${pbxfuncname} in -ljansson" >&5
+$as_echo_n "checking for ${pbxfuncname} in -ljansson... " >&6; }
+if eval \${$as_ac_Lib+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ljansson ${pbxlibdir}  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char ${pbxfuncname} ();
+int
+main ()
+{
+return ${pbxfuncname} ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$as_ac_Lib=yes"
+else
+  eval "$as_ac_Lib=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+eval ac_res=\$$as_ac_Lib
+              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+if eval test \"x\$"$as_ac_Lib"\" = x"yes"; then :
+  AST_JANSSON_FOUND=yes
+else
+  AST_JANSSON_FOUND=no
+fi
+
+      CFLAGS="${ast_ext_lib_check_save_CFLAGS}"
+   fi
+
+   # now check for the header.
+   if test "${AST_JANSSON_FOUND}" = "yes"; then
+      JANSSON_LIB="${pbxlibdir} -ljansson "
+      # if --with-JANSSON=DIR has been specified, use it.
+      if test "x${JANSSON_DIR}" != "x"; then
+         JANSSON_INCLUDE="-I${JANSSON_DIR}/include"
+      fi
+      JANSSON_INCLUDE="${JANSSON_INCLUDE} "
+      if test "xjansson.h" = "x" ; then        # no header, assume found
+         JANSSON_HEADER_FOUND="1"
+      else                             # check for the header
+         ast_ext_lib_check_saved_CPPFLAGS="${CPPFLAGS}"
+         CPPFLAGS="${CPPFLAGS} ${JANSSON_INCLUDE}"
+         ac_fn_c_check_header_mongrel "$LINENO" "jansson.h" "ac_cv_header_jansson_h" "$ac_includes_default"
+if test "x$ac_cv_header_jansson_h" = xyes; then :
+  JANSSON_HEADER_FOUND=1
+else
+  JANSSON_HEADER_FOUND=0
+fi
+
+
+         CPPFLAGS="${ast_ext_lib_check_saved_CPPFLAGS}"
+      fi
+      if test "x${JANSSON_HEADER_FOUND}" = "x0" ; then
+         JANSSON_LIB=""
+         JANSSON_INCLUDE=""
+      else
+         if test "x${pbxfuncname}" = "x" ; then                # only checking headers -> no library
+            JANSSON_LIB=""
+         fi
+         PBX_JANSSON=1
+         cat >>confdefs.h <<_ACEOF
+#define HAVE_JANSSON 1
+_ACEOF
+
+      fi
+   fi
+fi
+
+
+
 # BSD (and OS X) equivalent of inotify
 
 if test "x${PBX_KQUEUE}" != "x1" -a "${USE_KQUEUE}" != "no"; then
index 2b72b4e..536d442 100644 (file)
@@ -406,6 +406,7 @@ AST_EXT_LIB_SETUP([INOTIFY], [inotify support], [inotify])
 AST_EXT_LIB_SETUP([IODBC], [iODBC], [iodbc])
 AST_EXT_LIB_SETUP([ISDNNET], [ISDN4Linux], [isdnnet])
 AST_EXT_LIB_SETUP([JACK], [Jack Audio Connection Kit], [jack])
+AST_EXT_LIB_SETUP([JANSSON], [Jansson JSON library], [jansson])
 AST_EXT_LIB_SETUP([KQUEUE], [kqueue support], [kqueue])
 AST_EXT_LIB_SETUP([LDAP], [OpenLDAP], [ldap])
 AST_LIBCURL_CHECK_CONFIG([], [7.10.1])
@@ -1846,6 +1847,8 @@ AST_EXT_LIB_CHECK([INOTIFY], [c], [inotify_init], [sys/inotify.h])
 
 AST_EXT_LIB_CHECK([JACK], [jack], [jack_activate], [jack/jack.h])
 
+AST_EXT_LIB_CHECK([JANSSON], [jansson], [json_dumps], [jansson.h])
+
 # BSD (and OS X) equivalent of inotify
 AST_EXT_LIB_CHECK([KQUEUE], [c], [kqueue], [sys/event.h])
 
index b59e357..1359f9b 100755 (executable)
@@ -27,7 +27,7 @@ PACKAGES_DEBIAN="$PACKAGES_DEBIAN libcurl-dev libspeex-dev libspeexdsp-dev libog
 PACKAGES_DEBIAN="$PACKAGES_DEBIAN libpq-dev unixodbc-dev libsqlite0-dev libmysqlclient15-dev libneon27-dev libgmime-dev libusb-dev liblua5.1-0-dev lua5.1"
 PACKAGES_DEBIAN="$PACKAGES_DEBIAN libopenh323-dev libvpb-dev libgtk2.0-dev libmysqlclient-dev libbluetooth-dev libradiusclient-ng-dev freetds-dev"
 PACKAGES_DEBIAN="$PACKAGES_DEBIAN libsnmp-dev libiksemel-dev libcorosync-dev libnewt-dev libpopt-dev libical-dev libspandsp-dev libjack-dev"
-PACKAGES_DEBIAN="$PACKAGES_DEBIAN libresample-dev libc-client-dev binutils-dev libsrtp-dev libgsm1-dev libedit-dev doxygen"
+PACKAGES_DEBIAN="$PACKAGES_DEBIAN libresample-dev libc-client-dev binutils-dev libsrtp-dev libgsm1-dev libedit-dev doxygen libjansson-dev"
 PACKAGES_RH="automake gcc gcc-c++ ncurses-devel openssl-devel libxml2-devel unixODBC-devel libcurl-devel libogg-devel libvorbis-devel speex-devel"
 PACKAGES_RH="$PACKAGES_RH spandsp-devel freetds-devel net-snmp-devel iksemel-devel corosynclib-devel newt-devel popt-devel libtool-ltdl-devel lua-devel"
 PACKAGES_RH="$PACKAGES_RH libsqlite3x-devel radiusclient-ng-devel portaudio-devel postgresql-devel libresample-devel neon-devel libical-devel"
index 07ea752..52e96c0 100644 (file)
 /* Define to 1 if you have the Jack Audio Connection Kit library. */
 #undef HAVE_JACK
 
+/* Define to 1 if you have the Jansson JSON library library. */
+#undef HAVE_JANSSON
+
 /* Define to 1 if you have the `kevent64' function. */
 #undef HAVE_KEVENT64
 
diff --git a/include/asterisk/json.h b/include/asterisk/json.h
new file mode 100644 (file)
index 0000000..d287bd6
--- /dev/null
@@ -0,0 +1,762 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * David M. Lee, II <dlee@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#ifndef _ASTERISK_JSON_H
+#define _ASTERISK_JSON_H
+
+/*! \file
+ *
+ * \brief Asterisk JSON abstraction layer.
+ * \since 12.0.0
+ *
+ * This is a very thin wrapper around the Jansson API. For more details on it, see its
+ * docs at http://www.digip.org/jansson/doc/2.4/apiref.html.
+
+ * \author David M. Lee, II <dlee@digium.com>
+ */
+
+/*!@{*/
+
+/*!
+ * \brief Set custom allocators instead of the standard ast_malloc() and ast_free().
+ * \since 12.0.0
+ *
+ * This is used by the unit tests to do JSON specific memory leak detection. Since it
+ * affects all users of the JSON library, shouldn't normally be used.
+ *
+ * \param malloc_fn Custom allocation function.
+ * \param free_fn Matching free function.
+ */
+void ast_json_set_alloc_funcs(void *(*malloc_fn)(size_t), void (*free_fn)(void*));
+
+/*!
+ * \brief Change alloc funcs back to the resource module defaults.
+ * \since 12.0.0
+ *
+ * If you use ast_json_set_alloc_funcs() to temporarily change the allocator functions
+ * (i.e., from in a unit test), this function sets them back to ast_malloc() and
+ * ast_free().
+ */
+void ast_json_reset_alloc_funcs(void);
+
+/*!
+ * \struct ast_json
+ * \brief Abstract JSON element (object, array, string, int, ...).
+ * \since 12.0.0
+ */
+struct ast_json;
+
+/*!
+ * \brief Increase refcount on \a value.
+ * \since 12.0.0
+ *
+ * \param value JSON value to reference.
+ * \return The given \a value.
+ */
+struct ast_json *ast_json_ref(struct ast_json *value);
+
+/*!
+ * \brief Decrease refcount on \a value. If refcount reaches zero, \a value is freed.
+ * \since 12.0.0
+ */
+void ast_json_unref(struct ast_json *value);
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Valid types of a JSON element.
+ * \since 12.0.0
+ */
+enum ast_json_type
+{
+       AST_JSON_OBJECT,
+       AST_JSON_ARRAY,
+       AST_JSON_STRING,
+       AST_JSON_INTEGER,
+       AST_JSON_REAL,
+       AST_JSON_TRUE,
+       AST_JSON_FALSE,
+       AST_JSON_NULL,
+};
+
+/*!
+ * \brief Get the type of \a value.
+ * \since 12.0.0
+ * \param value Value to query.
+ * \return Type of \a value.
+ */
+enum ast_json_type ast_json_typeof(const struct ast_json *value);
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Get the JSON true value.
+ * \since 12.0.0
+ *
+ * The returned value is a singleton, and does not need to be
+ * ast_json_unref()'ed.
+ *
+ * \return JSON true.
+ */
+struct ast_json *ast_json_true(void);
+
+/*!
+ * \brief Get the JSON false value.
+ * \since 12.0.0
+ *
+ * The returned value is a singleton, and does not need to be
+ * ast_json_unref()'ed.
+ *
+ * \return JSON false.
+ */
+struct ast_json *ast_json_false(void);
+
+/*!
+ * \brief Get the JSON boolean corresponding to \a value.
+ * \since 12.0.0
+ * \return JSON true if value is true (non-zero).
+ * \return JSON false if value is false (zero).
+ */
+struct ast_json *ast_json_boolean(int value);
+
+/*!
+ * \brief Get the JSON null value.
+ * \since 12.0.0
+ *
+ * The returned value is a singleton, and does not need to be
+ * ast_json_unref()'ed.
+ *
+ * \return JSON null.
+ */
+struct ast_json *ast_json_null(void);
+
+/*!
+ * \brief Check if \a value is JSON true.
+ * \since 12.0.0
+ * \return True (non-zero) if \a value == \ref ast_json_true().
+ * \return False (zero) otherwise..
+ */
+int ast_json_is_true(const struct ast_json *value);
+
+/*!
+ * \brief Check if \a value is JSON false.
+ * \since 12.0.0
+ * \return True (non-zero) if \a value == \ref ast_json_false().
+ * \return False (zero) otherwise.
+ */
+int ast_json_is_false(const struct ast_json *value);
+
+/*!
+ * \brief Check if \a value is JSON null.
+ * \since 12.0.0
+ * \return True (non-zero) if \a value == \ref ast_json_false().
+ * \return False (zero) otherwise.
+ */
+int ast_json_is_null(const struct ast_json *value);
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Construct a JSON string from \a value.
+ * \since 12.0.0
+ *
+ * The given \a value must be a valid ASCII or UTF-8 encoded string.
+ *
+ * \param value Value of new JSON string.
+ * \return Newly constructed string element.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_string_create(const char *value);
+
+/*!
+ * \brief Get the value of a JSON string.
+ * \since 12.0.0
+ * \param string JSON string.
+ * \return Value of the string.
+ * \return \c NULL on error.
+ */
+const char *ast_json_string_get(const struct ast_json *string);
+
+/*!
+ * \brief Change the value of a JSON string.
+ * \since 12.0.0
+ *
+ * The given \a value must be a valid ASCII or UTF-8 encoded string.
+ *
+ * \param string JSON string to modify.
+ * \param value New value to store in \a string.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_string_set(struct ast_json *string, const char *value);
+
+/*!
+ * \brief Create a JSON string, printf style.
+ * \since 12.0.0
+ *
+ * The formatted value must be a valid ASCII or UTF-8 encoded string.
+ *
+ * \param format \c printf style format string.
+ * \return Newly allocated string.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_stringf(const char *format, ...) __attribute__((format(printf, 1, 2)));
+
+/*!
+ * \brief Create a JSON string, vprintf style.
+ * \since 12.0.0
+ *
+ * The formatted value must be a valid ASCII or UTF-8 encoded string.
+ *
+ * \param format \c printf style format string.
+ * \return Newly allocated string.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_vstringf(const char *format, va_list args) __attribute__((format(printf, 1, 0)));
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Create a JSON integer.
+ * \since 12.0.0
+ * \param value Value of the new JSON integer.
+ * \return Newly allocated integer.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_integer_create(intmax_t value);
+
+/*!
+ * \brief Get the value from a JSON integer.
+ * \since 12.0.0
+ * \param integer JSON integer.
+ * \return Value of a JSON integer.
+ * \return 0 if \a integer is not a JSON integer.
+ */
+intmax_t ast_json_integer_get(const struct ast_json *integer);
+
+/*!
+ * \brief Set the value of a JSON integer.
+ * \since 12.0.0
+ * \param integer JSON integer to modify.
+ * \param value New value for \a integer.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_integer_set(struct ast_json *integer, intmax_t value);
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Create a empty JSON array.
+ * \since 12.0.0
+ * \return Newly allocated array.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_array_create(void);
+
+/*!
+ * \brief Get the size of a JSON array.
+ * \since 12.0.0
+ * \param array JSON array.
+ * \return Size of \a array.
+ * \return 0 if array is not a JSON array.
+ */
+size_t ast_json_array_size(const struct ast_json *array);
+
+/*!
+ * \brief Get an element from an array.
+ * \since 12.0.0
+ *
+ * The returned element is a borrowed reference; use ast_json_ref() to safely keep a
+ * pointer to it.
+ *
+ * \param array JSON array.
+ * \param index Zero-based index into \a array.
+ * \return The specified element.
+ * \return \c NULL if \a array not an array.
+ * \return \c NULL if \a index is out of bounds.
+ */
+struct ast_json *ast_json_array_get(const struct ast_json *array, size_t index);
+
+/*!
+ * \brief Change an element in an array.
+ * \since 12.0.0
+ *
+ * The \a array steals the \a value reference; use ast_json_ref() to safely keep a pointer
+ * to it.
+ *
+ * \param array JSON array to modify.
+ * \param index Zero-based index into array.
+ * \param value New JSON value to store in \a array at \a index.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_array_set(struct ast_json *array, size_t index, struct ast_json *value);
+
+/*!
+ * \brief Append to an array.
+ * \since 12.0.0
+ *
+ * The array steals the \a value reference; use ast_json_ref() to safely keep a pointer
+ * to it.
+ *
+ * \param array JSON array to modify.
+ * \param value New JSON value to store at the end of \a array.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_array_append(struct ast_json *array, struct ast_json *value);
+
+/*!
+ * \brief Insert into an array.
+ * \since 12.0.0
+ *
+ * The array steals the \a value reference; use ast_json_ref() to safely keep a pointer
+ * to it.
+ *
+ * \param array JSON array to modify.
+ * \param index Zero-based index into array.
+ * \param value New JSON value to store in \a array at \a index.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_array_insert(struct ast_json *array, size_t index, struct ast_json *value);
+
+/*!
+ * \brief Remove an element from an array.
+ * \since 12.0.0
+ * \param array JSON array to modify.
+ * \param index Zero-based index into array.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_array_remove(struct ast_json *array, size_t index);
+
+/*!
+ * \brief Remove all elements from an array.
+ * \since 12.0.0
+ * \param array JSON array to clear.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_array_clear(struct ast_json *array);
+
+/*!
+ * \brief Append all elements from \a tail to \a array.
+ * \since 12.0.0
+ *
+ * The \a tail argument is not changed, so ast_json_unref() it when you are done with it.
+ *
+ * \param array JSON array to modify.
+ * \param tail JSON array with contents to append to \a array.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_array_extend(struct ast_json *array, struct ast_json *tail);
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Create a new JSON object.
+ * \since 12.0.0
+ * \return Newly allocated object.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_object_create(void);
+
+/*!
+ * \brief Get size of JSON object.
+ * \since 12.0.0
+ * \param object JSON object.
+ * \return Size of \a object.
+ * \return Zero of \a object is not a JSON object.
+ */
+size_t ast_json_object_size(struct ast_json *object);
+
+/*!
+ * \brief Get a field from a JSON object.
+ * \since 12.0.0
+ *
+ * The returned element is a borrowed reference; use ast_json_ref() to safely keep a
+ * pointer to it.
+ *
+ * \param object JSON object.
+ * \param key Key of field to look up.
+ * \return Value with given \a key.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_object_get(struct ast_json *object, const char *key);
+
+/*!
+ * \brief Set a field in a JSON object.
+ * \since 12.0.0
+ *
+ * The object steals the \a value reference; use ast_json_ref() to safely keep a pointer
+ * to it.
+ *
+ * \param object JSON object to modify.
+ * \param key Key of field to set.
+ * \param value JSON value to set for field.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value);
+
+/*!
+ * \brief Delete a field from a JSON object.
+ * \since 12.0.0
+ *
+ * \param object JSON object to modify.
+ * \param key Key of field to delete.
+ * \return 0 on success, or -1 if key does not exist.
+ */
+int ast_json_object_del(struct ast_json *object, const char *key);
+
+/*!
+ * \brief Delete all elements from a JSON object.
+ * \since 12.0.0
+ * \param object JSON object to clear.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_object_clear(struct ast_json *object);
+
+/*!
+ * \brief Update \a object with all of the fields of \a other.
+ * \since 12.0.0
+ *
+ * All of the fields of \a other are copied into \a object, overwriting existing keys.
+ * The \a other object is not changed, so ast_json_unref() it when you are done with it.
+ *
+ * \param object JSON object to modify.
+ * \param other JSON object to copy into \a object.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_object_update(struct ast_json *object, struct ast_json *other);
+
+/*!
+ * \brief Update existing fields in \a object with the fields of \a other.
+ * \since 12.0.0
+ *
+ * Like ast_json_object_update(), but only existing fields are updated. No new fields
+ * will get added. The \a other object is not changed, so ast_json_unref() it when you
+ * are done with it.
+ *
+ * \param object JSON object to modify.
+ * \param other JSON object to copy into \a object.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_object_update_existing(struct ast_json *object, struct ast_json *other);
+
+/*!
+ * \brief Add new fields to \a object with the fields of \a other.
+ * \since 12.0.0
+ *
+ * Like ast_json_object_update(), but only missing fields are added. No existing fields
+ * will be modified. The \a other object is not changed, so ast_json_unref() it when you
+ * are done with it.
+ *
+ * \param object JSON object to modify.
+ * \param other JSON object to copy into \a object.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_object_update_missing(struct ast_json *object, struct ast_json *other);
+
+/*!
+ * \struct ast_json_iter
+ * \brief Iterator for JSON object key/values.
+ * \since 12.0.0
+ *
+ * Note that iteration order is not specified, and may change as fields are added to
+ * and removed from the object.
+ */
+struct ast_json_iter;
+
+/*!
+ * \brief Get an iterator pointing to the first field in a JSON object.
+ * \since 12.0.0
+ *
+ * The order of the fields in an object are not specified. However, iterating forward
+ * from this iterator will cover all fields in \a object. Adding or removing fields from
+ * \a object may invalidate its iterators.
+ *
+ * \param object JSON object.
+ * \return Iterator to the first field in \a object.
+ * \return \c NULL \a object is empty.
+ * \return \c NULL on error.
+ */
+struct ast_json_iter *ast_json_object_iter(struct ast_json *object);
+
+/*!
+ * \brief Get an iterator pointing to a specified \a key in \a object.
+ * \since 12.0.0
+ *
+ * Iterating forward from this iterator may not to cover all elements in \a object.
+ *
+ * \param object JSON object to iterate.
+ * \param key Key of field to lookup.
+ * \return Iterator pointing to the field with the given \a key.
+ * \return \c NULL if \a key does not exist.
+ * \return \c NULL on error.
+ */
+struct ast_json_iter *ast_json_object_iter_at(struct ast_json *object, const char *key);
+
+/*!
+ * \brief Get the next iterator.
+ * \since 12.0.0
+ * \param object JSON object \a iter was obtained from.
+ * \param iter JSON object iterator.
+ * \return Iterator to next field in \a object.
+ * \return \c NULL if \a iter was the last field.
+ */
+struct ast_json_iter *ast_json_object_iter_next(struct ast_json *object, struct ast_json_iter *iter);
+
+/*!
+ * \brief Get the key from an iterator.
+ * \since 12.0.0
+ * \param iter JSON object iterator.
+ * \return Key of the field \a iter points to.
+ */
+const char *ast_json_object_iter_key(struct ast_json_iter *iter);
+
+/*!
+ * \brief Get the value from an iterator.
+ * \since 12.0.0
+ *
+ * The returned element is a borrowed reference; use ast_json_ref() to safely
+ * keep a pointer to it.
+ *
+ * \param iter JSON object iterator.
+ * \return Value of the field \a iter points to.
+ */
+struct ast_json *ast_json_object_iter_value(struct ast_json_iter *iter);
+
+/*!
+ * \brief Set the value of the field pointed to by an iterator.
+ * \since 12.0.0
+ *
+ * The array steals the value reference; use ast_json_ref() to safely keep a
+ * pointer to it.
+ *
+ * \param object JSON object \a iter was obtained from.
+ * \param iter JSON object iterator.
+ * \param value JSON value to store in \iter's field.
+ * \return 0 on success.
+ * \return -1 on error.
+ */
+int ast_json_object_iter_set(struct ast_json *object, struct ast_json_iter *iter, struct ast_json *value);
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Encode a JSON value to a string.
+ * \since 12.0.0
+ *
+ * Returned string must be freed by calling ast_free().
+ *
+ * \param JSON value.
+ * \return String encoding of \a root.
+ * \return \c NULL on error.
+ */
+char *ast_json_dump_string(struct ast_json *root);
+
+/*!
+ * \brief Encode a JSON value to an \ref ast_str.
+ * \since 12.0.0
+ *
+ * If \a dst is too small, it will be grown as needed.
+ *
+ * \param root JSON value.
+ * \param dst \ref ast_str to store JSON encoding.
+ * \return 0 on success.
+ * \return -1 on error. The contents of \a dst are undefined.
+ */
+int ast_json_dump_str(struct ast_json *root, struct ast_str **dst);
+
+/*!
+ * \brief Encode a JSON value to a \c FILE.
+ * \since 12.0.0
+ *
+ * \param root JSON value.
+ * \param output File to write JSON encoding to.
+ * \return 0 on success.
+ * \return -1 on error. The contents of \a output are undefined.
+ */
+int ast_json_dump_file(struct ast_json *root, FILE *output);
+
+/*!
+ * \brief Encode a JSON value to a file at the given location.
+ * \since 12.0.0
+ *
+ * \param root JSON value.
+ * \param path Path to file to write JSON encoding to.
+ * \return 0 on success.
+ * \return -1 on error. The contents of \a output are undefined.
+ */
+int ast_json_dump_new_file(struct ast_json *root, const char *path);
+
+#define AST_JSON_ERROR_TEXT_LENGTH    160
+#define AST_JSON_ERROR_SOURCE_LENGTH   80
+
+/*!
+ * \brief JSON parsing error information.
+ * \since 12.0.0
+ */
+struct ast_json_error {
+       /*! Line number error occured on */
+       int line;
+       /*! Character (not byte, can be different for UTF-8) column on which the error occurred. */
+       int column;
+       /*! Position in bytes from start of input */
+       int position;
+       /*! Error message */
+       char text[AST_JSON_ERROR_TEXT_LENGTH];
+       /*! Source of the error (filename or <string>) */
+       char source[AST_JSON_ERROR_TEXT_LENGTH];
+};
+
+/*!
+ * \brief Parse null terminated string into a JSON object or array.
+ * \since 12.0.0
+ * \param input String to parse.
+ * \param[out] error Filled with information on error.
+ * \return Parsed JSON element.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_load_string(const char *input, struct ast_json_error *error);
+
+/*!
+ * \brief Parse \ref ast_str into a JSON object or array.
+ * \since 12.0.0
+ * \param input \ref ast_str to parse.
+ * \param[out] error Filled with information on error.
+ * \return Parsed JSON element.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_load_str(const struct ast_str *input, struct ast_json_error *error);
+
+/*!
+ * \brief Parse buffer with known length into a JSON object or array.
+ * \since 12.0.0
+ * \param buffer Buffer to parse.
+ * \param buflen Length of \a buffer.
+ * \param[out] error Filled with information on error.
+ * \return Parsed JSON element.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_load_buf(const char *buffer, size_t buflen, struct ast_json_error *error);
+
+/*!
+ * \brief Parse a \c FILE into JSON object or array.
+ * \since 12.0.0
+ * \param input \c FILE to parse.
+ * \param[out] error Filled with information on error.
+ * \return Parsed JSON element.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_load_file(FILE *input, struct ast_json_error *error);
+
+/*!
+ * \brief Parse file at \a path into JSON object or array.
+ * \since 12.0.0
+ * \param path Path of file to parse.
+ * \param[out] error Filled with information on error.
+ * \return Parsed JSON element.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_load_new_file(const char *path, struct ast_json_error *error);
+
+/*!
+ * \brief Helper for creating complex JSON values.
+ * \since 12.0.0
+ *
+ * See original Jansson docs at http://www.digip.org/jansson/doc/2.4/apiref.html#apiref-pack
+ * for more details.
+ */
+struct ast_json *ast_json_pack(char const *format, ...);
+
+/*!
+ * \brief Helper for creating complex JSON values simply.
+ * \since 12.0.0
+ *
+ * See original Jansson docs at http://www.digip.org/jansson/doc/2.4/apiref.html#apiref-pack
+ * for more details.
+ */
+struct ast_json *ast_json_vpack(char const *format, va_list ap);
+
+/*!@}*/
+
+/*!@{*/
+
+/*!
+ * \brief Compare two JSON objects.
+ * \since 12.0.0
+ *
+ * Two JSON objects are equal if they are of the same type, and their contents are equal.
+ *
+ * \param lhs Value to compare.
+ * \param rhs Other value to compare.
+ * \return True (non-zero) if \a lhs and \a rhs are equal.
+ * \return False (zero) if they are not.
+ */
+int ast_json_equal(const struct ast_json *lhs, const struct ast_json *rhs);
+
+/*!
+ * \brief Copy a JSON value, but not its children.
+ * \since 12.0.0
+ *
+ * If \a value is a JSON object or array, its children are shared with the returned copy.
+ *
+ * \param value JSON value to copy.
+ * \return Shallow copy of \a value.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_copy(const struct ast_json *value);
+
+/*!
+ * \brief Copy a JSON value, and its children.
+ * \since 12.0.0
+ *
+ * If \a value is a JSON object or array, they are also copied.
+ *
+ * \param value JSON value to copy.
+ * \return Deep copy of \a value.
+ * \return \c NULL on error.
+ */
+struct ast_json *ast_json_deep_copy(const struct ast_json *value);
+
+/*!@}*/
+
+#endif /* _ASTERISK_JSON_H */
index ea79385..5ad389f 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * Asterisk -- An open source telephony toolkit.
  *
- * Copyright (C) 2009-2010, Digium, Inc.
+ * Copyright (C) 2009-2013, Digium, Inc.
  *
  * David Vossel <dvossel@digium.com>
  * Russell Bryant <russell@digium.com>
@@ -283,5 +283,31 @@ int __ast_test_status_update(const char *file, const char *func, int line, struc
  */
 #define ast_test_status_update(t, f, ...) __ast_test_status_update(__FILE__, __PRETTY_FUNCTION__, __LINE__, (t), (f), ## __VA_ARGS__)
 
+/*!
+ * \brief Check a test condition, failing the test if it's not true.
+ *
+ * \since 12.0.0
+ *
+ * This macro evaluates \a condition. If the condition evaluates to true (non-zero),
+ * nothing happens. If it evaluates to false (zero), then the failure is printed
+ * using \ref ast_test_status_update, and the current test is ended with AST_TEST_FAIL.
+ *
+ * Sadly, the name 'ast_test_assert' was already taken.
+ *
+ * Note that since this macro returns from the current test, there must not be any
+ * cleanup work to be done before returning. Use \ref RAII_VAR for test cleanup.
+ *
+ * \param \a test Currently executing test
+ * \param \a condition Boolean condition to check.
+ */
+#define ast_test_validate(test, condition)                             \
+       do {                                                            \
+               if (!(condition)) {                                     \
+                       __ast_test_status_update(__FILE__, __PRETTY_FUNCTION__, __LINE__, (test), "Condition failed: %s\n", #condition); \
+                       return AST_TEST_FAIL;                           \
+               }                                                       \
+       } while(0)
+
+
 #endif /* TEST_FRAMEWORK */
 #endif /* _AST_TEST_H */
index d0a2d05..fbb885c 100644 (file)
@@ -35,6 +35,7 @@ AST_LIBS+=$(BKTR_LIB)
 AST_LIBS+=$(LIBXML2_LIB)
 AST_LIBS+=$(SQLITE3_LIB)
 AST_LIBS+=$(ASTSSL_LIBS)
+AST_LIBS+=$(JANSSON_LIB)
 
 ifneq ($(findstring $(OSARCH), linux-gnu uclinux linux-uclibc linux-gnueabi kfreebsd-gnu linux-gnueabihf),)
   ifneq ($(findstring LOADABLE_MODULES,$(MENUSELECT_CFLAGS)),)
index 01cc707..c10507f 100644 (file)
@@ -169,6 +169,9 @@ IODBC_LIB=@IODBC_LIB@
 JACK_INCLUDE=@JACK_INCLUDE@
 JACK_LIB=@JACK_LIB@
 
+JANSSON_INCLUDE=@JANSSON_INCLUDE@
+JANSSON_LIB=@JANSSON_LIB@
+
 LDAP_INCLUDE=@LDAP_INCLUDE@
 LDAP_LIB=@LDAP_LIB@
 
diff --git a/res/res_json.c b/res/res_json.c
new file mode 100644 (file)
index 0000000..218c09b
--- /dev/null
@@ -0,0 +1,517 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * David M. Lee, II <dlee@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief JSON abstraction layer.
+ *
+ * This is a very thin wrapper around the Jansson API. For more details on it, see its
+ * docs at http://www.digip.org/jansson/doc/2.4/apiref.html.
+ *
+ * \author David M. Lee, II <dlee@digium.com>
+ */
+
+/*** MODULEINFO
+       <depend>jansson</depend>
+       <support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/json.h"
+#include "asterisk/module.h"
+#include "asterisk/utils.h"
+
+#include <jansson.h>
+
+/*!
+ * \brief Function wrapper around ast_malloc macro.
+ */
+static void *json_malloc(size_t size)
+{
+       return ast_malloc(size);
+}
+
+/*!
+ * \brief Function wrapper around ast_free macro.
+ */
+static void json_free(void *p)
+{
+       ast_free(p);
+}
+
+void ast_json_set_alloc_funcs(void *(*malloc_fn)(size_t), void (*free_fn)(void*))
+{
+       json_set_alloc_funcs(malloc_fn, free_fn);
+}
+
+void ast_json_reset_alloc_funcs(void)
+{
+       json_set_alloc_funcs(json_malloc, json_free);
+}
+
+struct ast_json *ast_json_ref(struct ast_json *json)
+{
+       json_incref((json_t *)json);
+       return json;
+}
+
+void ast_json_unref(struct ast_json *json)
+{
+       json_decref((json_t *)json);
+}
+
+enum ast_json_type ast_json_typeof(const struct ast_json *json)
+{
+       int r = json_typeof((json_t*)json);
+       switch(r) {
+       case JSON_OBJECT: return AST_JSON_OBJECT;
+       case JSON_ARRAY: return AST_JSON_ARRAY;
+       case JSON_STRING: return AST_JSON_STRING;
+       case JSON_INTEGER: return AST_JSON_INTEGER;
+       case JSON_REAL: return AST_JSON_REAL;
+       case JSON_TRUE: return AST_JSON_TRUE;
+       case JSON_FALSE: return AST_JSON_FALSE;
+       case JSON_NULL: return AST_JSON_NULL;
+       }
+       ast_assert(0); /* Unexpect return from json_typeof */
+       return r;
+}
+
+struct ast_json *ast_json_true(void)
+{
+       return (struct ast_json *)json_true();
+}
+
+struct ast_json *ast_json_false(void)
+{
+       return (struct ast_json *)json_false();
+}
+
+struct ast_json *ast_json_boolean(int value)
+{
+#if JANSSON_VERSION_HEX >= 0x020400
+       return (struct ast_json *)json_boolean(value);
+#else
+       return value ? ast_json_true() : ast_json_false();
+#endif
+}
+
+struct ast_json *ast_json_null(void)
+{
+       return (struct ast_json *)json_null();
+}
+
+int ast_json_is_true(const struct ast_json *json)
+{
+       return json_is_true((const json_t *)json);
+}
+
+int ast_json_is_false(const struct ast_json *json)
+{
+       return json_is_false((const json_t *)json);
+}
+
+int ast_json_is_null(const struct ast_json *json)
+{
+       return json_is_null((const json_t *)json);
+}
+
+struct ast_json *ast_json_string_create(const char *value)
+{
+       return (struct ast_json *)json_string(value);
+}
+
+const char *ast_json_string_get(const struct ast_json *string)
+{
+       return json_string_value((json_t *)string);
+}
+
+int ast_json_string_set(struct ast_json *string, const char *value)
+{
+       return json_string_set((json_t *)string, value);
+}
+
+struct ast_json *ast_json_stringf(const char *format, ...)
+{
+       struct ast_json *ret;
+       va_list args;
+       va_start(args, format);
+       ret = ast_json_vstringf(format, args);
+       va_end(args);
+       return ret;
+}
+
+struct ast_json *ast_json_vstringf(const char *format, va_list args)
+{
+       char *str = NULL;
+       json_t *ret = NULL;
+
+       if (format) {
+               int err = vasprintf(&str, format, args);
+               if (err > 0) {
+                       ret = json_string(str);
+                       free(str);
+               }
+       }
+       return (struct ast_json *)ret;
+}
+
+struct ast_json *ast_json_integer_create(intmax_t value)
+{
+       return (struct ast_json *)json_integer(value);
+}
+
+intmax_t ast_json_integer_get(const struct ast_json *integer)
+{
+       return json_integer_value((json_t *)integer);
+}
+
+int ast_json_integer_set(struct ast_json *integer, intmax_t value)
+{
+       return json_integer_set((json_t *)integer, value);
+}
+
+
+int ast_json_equal(const struct ast_json *lhs, const struct ast_json *rhs)
+{
+       return json_equal((json_t *)lhs, (json_t *)rhs);
+}
+
+struct ast_json *ast_json_array_create(void)
+{
+       return (struct ast_json *)json_array();
+}
+size_t ast_json_array_size(const struct ast_json *array)
+{
+       return json_array_size((json_t *)array);
+}
+struct ast_json *ast_json_array_get(const struct ast_json *array, size_t index)
+{
+       return (struct ast_json *)json_array_get((json_t *)array, index);
+}
+int ast_json_array_set(struct ast_json *array, size_t index, struct ast_json *value)
+{
+       return json_array_set_new((json_t *)array, index, (json_t *)value);
+}
+int ast_json_array_append(struct ast_json *array, struct ast_json *value)
+{
+       return json_array_append_new((json_t *)array, (json_t *)value);
+}
+int ast_json_array_insert(struct ast_json *array, size_t index, struct ast_json *value)
+{
+       return json_array_insert_new((json_t *)array, index, (json_t *)value);
+}
+int ast_json_array_remove(struct ast_json *array, size_t index)
+{
+       return json_array_remove((json_t *)array, index);
+}
+int ast_json_array_clear(struct ast_json *array)
+{
+       return json_array_clear((json_t *)array);
+}
+int ast_json_array_extend(struct ast_json *array, struct ast_json *tail)
+{
+       return json_array_extend((json_t *)array, (json_t *)tail);
+}
+
+struct ast_json *ast_json_object_create(void)
+{
+       return (struct ast_json *)json_object();
+}
+size_t ast_json_object_size(struct ast_json *object)
+{
+       return json_object_size((json_t *)object);
+}
+struct ast_json *ast_json_object_get(struct ast_json *object, const char *key)
+{
+       if (key) {
+               return (struct ast_json *)json_object_get((json_t *)object, key);
+       }
+       return NULL;
+}
+int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value)
+{
+       return json_object_set_new((json_t *)object, key, (json_t *)value);
+}
+int ast_json_object_del(struct ast_json *object, const char *key)
+{
+       return json_object_del((json_t *)object, key);
+}
+int ast_json_object_clear(struct ast_json *object)
+{
+       return json_object_clear((json_t *)object);
+}
+int ast_json_object_update(struct ast_json *object, struct ast_json *other)
+{
+       return json_object_update((json_t *)object, (json_t *)other);
+}
+int ast_json_object_update_existing(struct ast_json *object, struct ast_json *other)
+{
+#if JANSSON_VERSION_HEX >= 0x020300
+       return json_object_update_existing((json_t *)object, (json_t *)other);
+#else
+       struct ast_json_iter *iter = ast_json_object_iter(other);
+       int ret = 0;
+
+       if (object == NULL || other == NULL) {
+               return -1;
+       }
+
+       while (iter != NULL && ret == 0) {
+               const char *key = ast_json_object_iter_key(iter);
+               if (ast_json_object_get(object, key) != NULL) {
+                       ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
+               }
+               iter = ast_json_object_iter_next(other, iter);
+       }
+       return ret;
+#endif
+}
+int ast_json_object_update_missing(struct ast_json *object, struct ast_json *other)
+{
+#if JANSSON_VERSION_HEX >= 0x020300
+       return json_object_update_missing((json_t *)object, (json_t *)other);
+#else
+       struct ast_json_iter *iter = ast_json_object_iter(other);
+       int ret = 0;
+
+       if (object == NULL || other == NULL) {
+               return -1;
+       }
+
+       while (iter != NULL && ret == 0) {
+               const char *key = ast_json_object_iter_key(iter);
+               if (ast_json_object_get(object, key) == NULL) {
+                       ret = ast_json_object_set(object, key, ast_json_object_iter_value(iter));
+               }
+               iter = ast_json_object_iter_next(other, iter);
+       }
+       return ret;
+#endif
+}
+
+struct ast_json_iter *ast_json_object_iter(struct ast_json *object)
+{
+       return json_object_iter((json_t *)object);
+}
+struct ast_json_iter *ast_json_object_iter_at(struct ast_json *object, const char *key)
+{
+       return json_object_iter_at((json_t *)object, key);
+}
+struct ast_json_iter *ast_json_object_iter_next(struct ast_json *object, struct ast_json_iter *iter)
+{
+       return json_object_iter_next((json_t *)object, iter);
+}
+const char *ast_json_object_iter_key(struct ast_json_iter *iter)
+{
+       return json_object_iter_key(iter);
+}
+struct ast_json *ast_json_object_iter_value(struct ast_json_iter *iter)
+{
+       return (struct ast_json *)json_object_iter_value(iter);
+}
+int ast_json_object_iter_set(struct ast_json *object, struct ast_json_iter *iter, struct ast_json *value)
+{
+       return json_object_iter_set_new((json_t *)object, iter, (json_t *)value);
+}
+
+/*!
+ * \brief Default flags for JSON encoding.
+ */
+static size_t dump_flags(void)
+{
+       /* There's a chance this could become a runtime flag */
+       int flags = JSON_COMPACT;
+#ifdef AST_DEVMODE
+       /* In dev mode, write readable JSON */
+       flags = JSON_INDENT(2) | JSON_PRESERVE_ORDER;
+#endif
+       return flags;
+}
+
+char *ast_json_dump_string(struct ast_json *root)
+{
+       return json_dumps((json_t *)root, dump_flags());
+}
+
+static int write_to_ast_str(const char *buffer, size_t size, void *data)
+{
+       struct ast_str **dst = data;
+       size_t str_size = ast_str_size(*dst);
+       size_t remaining = str_size - ast_str_strlen(*dst);
+       int ret;
+
+       /* While ast_str_append will grow the ast_str, it won't report
+        * allocation errors. Fortunately, it's not that hard.
+        */
+
+       /* Remaining needs to be big enough for buffer, plus null char */
+       while (remaining < size + 1) {
+               /* doubling the size of the buffer gives us 'amortized
+                * constant' time.
+                * See http://stackoverflow.com/a/249695/115478 for info.
+                */
+               str_size *= 2;
+               remaining = str_size - ast_str_strlen(*dst);
+       }
+
+       ret = ast_str_make_space(dst, str_size);
+       if (ret == -1) {
+               /* Could not alloc; fail */
+               return -1;
+       }
+
+       ast_str_append_substr(dst, -1, buffer, size);
+       return 0;
+}
+
+int ast_json_dump_str(struct ast_json *root, struct ast_str **dst)
+{
+       return json_dump_callback((json_t *)root, write_to_ast_str, dst, dump_flags());
+}
+
+
+int ast_json_dump_file(struct ast_json *root, FILE *output)
+{
+       if (root && output) {
+               return json_dumpf((json_t *)root, output, dump_flags());
+       }
+       return -1;
+}
+int ast_json_dump_new_file(struct ast_json *root, const char *path)
+{
+       return json_dump_file((json_t *)root, path, dump_flags());
+}
+
+/*!
+ * \brief Copy Jansson error struct to ours.
+ */
+static void copy_error(struct ast_json_error *error, const json_error_t *jansson_error)
+{
+       if (error && jansson_error) {
+               error->line = jansson_error->line;
+               error->column = jansson_error->column;
+               error->position = jansson_error->position;
+               ast_copy_string(error->text, jansson_error->text, sizeof(error->text));
+               ast_copy_string(error->source, jansson_error->source, sizeof(error->source));
+       }
+
+}
+
+static void parse_error(struct ast_json_error *error, const char *text, const char *source)
+{
+       if (error != NULL) {
+               error->line = 0;
+               error->column = 0;
+               error->position = 0;
+               strncpy(error->text, text, sizeof(error->text));
+               strncpy(error->source, source, sizeof(error->text));
+       }
+}
+
+struct ast_json *ast_json_load_string(const char *input, struct ast_json_error *error)
+{
+       json_error_t jansson_error = {};
+       struct ast_json *r = NULL;
+       if (input != NULL) {
+               r = (struct ast_json *)json_loads(input, 0, &jansson_error);
+               copy_error(error, &jansson_error);
+       } else {
+               parse_error(error, "NULL input string", "<null>");
+       }
+       return r;
+}
+
+struct ast_json *ast_json_load_str(const struct ast_str *input, struct ast_json_error *error)
+{
+       return ast_json_load_string(ast_str_buffer(input), error);
+}
+
+struct ast_json *ast_json_load_buf(const char *buffer, size_t buflen, struct ast_json_error *error)
+{
+       json_error_t jansson_error = {};
+       struct ast_json *r = (struct ast_json *)json_loadb(buffer, buflen, 0, &jansson_error);
+       copy_error(error, &jansson_error);
+       return r;
+}
+struct ast_json *ast_json_load_file(FILE *input, struct ast_json_error *error)
+{
+       json_error_t jansson_error = {};
+       struct ast_json *r = NULL;
+       if (input != NULL) {
+               r = (struct ast_json *)json_loadf(input, 0, &jansson_error);
+               copy_error(error, &jansson_error);
+       } else {
+               parse_error(error, "NULL input file", "<null>");
+       }
+       return r;
+}
+struct ast_json *ast_json_load_new_file(const char *path, struct ast_json_error *error)
+{
+       json_error_t jansson_error = {};
+       struct ast_json *r = (struct ast_json *)json_load_file(path, 0, &jansson_error);
+       copy_error(error, &jansson_error);
+       return r;
+}
+
+struct ast_json *ast_json_pack(char const *format, ...)
+{
+       struct ast_json *ret;
+       va_list args;
+       va_start(args, format);
+       ret = ast_json_vpack(format, args);
+       va_end(args);
+       return ret;
+}
+struct ast_json *ast_json_vpack(char const *format, va_list ap)
+{
+       struct ast_json *r = NULL;
+       if (format) {
+               r = (struct ast_json *)json_vpack_ex(NULL, 0, format, ap);
+       }
+       return r;
+}
+
+struct ast_json *ast_json_copy(const struct ast_json *value)
+{
+       return (struct ast_json *)json_copy((json_t *)value);
+}
+struct ast_json *ast_json_deep_copy(const struct ast_json *value)
+{
+       return (struct ast_json *)json_deep_copy((json_t *)value);
+}
+
+static int unload_module(void)
+{
+       /* Nothing to do */
+       return 0;
+}
+
+static int load_module(void)
+{
+       /* Setup to use Asterisk custom allocators */
+       ast_json_reset_alloc_funcs();
+       return AST_MODULE_LOAD_SUCCESS;
+}
+
+AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "JSON library",
+               .load = load_module,
+               .unload = unload_module);
diff --git a/res/res_json.exports.in b/res/res_json.exports.in
new file mode 100644 (file)
index 0000000..bc07da5
--- /dev/null
@@ -0,0 +1,6 @@
+{
+       global:
+               LINKER_SYMBOL_PREFIXast_json_*;
+       local:
+               *;
+};
index 1e130e7..04db2dd 100644 (file)
@@ -440,6 +440,10 @@ static void xmpp_client_destructor(void *obj)
 
        ast_xmpp_client_disconnect(client);
 
+       if (client->filter) {
+               iks_filter_delete(client->filter);
+       }
+
        if (client->stack) {
                iks_stack_delete(client->stack);
        }
@@ -3408,12 +3412,6 @@ int ast_xmpp_client_disconnect(struct ast_xmpp_client *client)
                iks_disconnect(client->parser);
        }
 
-       /* Disconnecting the parser and going back to a disconnected state means any hooks should no longer be present */
-       if (client->filter) {
-               iks_filter_delete(client->filter);
-               client->filter = NULL;
-       }
-
        client->state = XMPP_STATE_DISCONNECTED;
 
        return 0;
diff --git a/tests/test_json.c b/tests/test_json.c
new file mode 100644 (file)
index 0000000..f67e352
--- /dev/null
@@ -0,0 +1,1701 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2012 - 2013, Digium, Inc.
+ *
+ * David M. Lee, II <dlee@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file \brief Test JSON API.
+ *
+ * While some of these tests are actually testing our JSON library wrapper, the bulk of
+ * them are exploratory tests to determine what the behavior of the underlying JSON
+ * library is. This also gives us a good indicator if that behavior changes between
+ * Jansson revisions.
+ *
+ * \author\verbatim David M. Lee, II <dlee@digium.com> \endverbatim
+ *
+ * \ingroup tests
+ */
+
+/*** MODULEINFO
+       <depend>TEST_FRAMEWORK</depend>
+       <depend>res_json</depend>
+       <support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+#include "asterisk/json.h"
+#include "asterisk/module.h"
+#include "asterisk/test.h"
+
+/*!
+ * Number of allocations from JSON library that have not yet been freed.
+ */
+static size_t alloc_count;
+
+/*!@{*/
+/*!
+ * JSON library has its own reference counting, so we'll provide our own allocators to
+ * test that everything gets freed as expected.
+ */
+static void *json_debug_malloc(size_t size)
+{
+       void *p = ast_malloc(size);
+       if (p) {
+               ++alloc_count;
+       }
+       return p;
+}
+
+static void json_debug_free(void *p)
+{
+       if (p) {
+               --alloc_count;
+       }
+       ast_free(p);
+}
+
+static void *json_test_init(struct ast_test *test)
+{
+       ast_json_set_alloc_funcs(json_debug_malloc, json_debug_free);
+       alloc_count = 0;
+       return test;
+}
+
+static void json_test_finish(void *test)
+{
+       struct ast_test *t = test;
+       ast_json_reset_alloc_funcs();
+       if (0 != alloc_count) {
+               ast_test_status_update(t, "JSON test leaked %zd allocations!", alloc_count);
+       }
+}
+
+/*!@}*/
+
+AST_TEST_DEFINE(json_test_false)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "false";
+               info->category = "/main/json/";
+               info->summary = "Testing fundamental JSON false value.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       uut = ast_json_false();
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_FALSE == ast_json_typeof(uut));
+       ast_test_validate(test, !ast_json_is_null(uut));
+       ast_test_validate(test, !ast_json_is_true(uut));
+       ast_test_validate(test, ast_json_is_false(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_true)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "true";
+               info->category = "/main/json/";
+               info->summary = "Testing JSON true value.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       uut = ast_json_true();
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_TRUE == ast_json_typeof(uut));
+       ast_test_validate(test, !ast_json_is_null(uut));
+       ast_test_validate(test, ast_json_is_true(uut));
+       ast_test_validate(test, !ast_json_is_false(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_bool0)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "bool0";
+               info->category = "/main/json/";
+               info->summary = "Testing JSON boolean function (false).";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       uut = ast_json_boolean(0);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_FALSE == ast_json_typeof(uut));
+       ast_test_validate(test, !ast_json_is_null(uut));
+       ast_test_validate(test, !ast_json_is_true(uut));
+       ast_test_validate(test, ast_json_is_false(uut));
+       ast_test_validate(test, ast_json_equal(uut, ast_json_false()));
+       ast_test_validate(test, !ast_json_equal(uut, ast_json_true()));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_bool1)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "bool1";
+               info->category = "/main/json/";
+               info->summary = "Testing JSON boolean function (true).";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       uut = ast_json_boolean(1);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_TRUE == ast_json_typeof(uut));
+       ast_test_validate(test, !ast_json_is_null(uut));
+       ast_test_validate(test, ast_json_is_true(uut));
+       ast_test_validate(test, !ast_json_is_false(uut));
+       ast_test_validate(test, !ast_json_equal(uut, ast_json_false()));
+       ast_test_validate(test, ast_json_equal(uut, ast_json_true()));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_null)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "null";
+               info->category = "/main/json/";
+               info->summary = "Testing JSON null value.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       uut = ast_json_null();
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_NULL == ast_json_typeof(uut));
+       ast_test_validate(test, ast_json_is_null(uut));
+       ast_test_validate(test, !ast_json_is_true(uut));
+       ast_test_validate(test, !ast_json_is_false(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_null_val)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "null_val";
+               info->category = "/main/json/";
+               info->summary = "Testing JSON handling of NULL.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* NULL isn't null, true or false */
+       ast_test_validate(test, !ast_json_is_null(NULL));
+       ast_test_validate(test, !ast_json_is_false(NULL));
+       ast_test_validate(test, !ast_json_is_true(NULL));
+
+       /* ref and unref should be NULL safe */
+       ast_json_ref(NULL);
+       ast_json_unref(NULL);
+       /* no segfault; we're good. le sigh. */
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_string)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "string";
+               info->category = "/main/json/";
+               info->summary = "Basic string tests.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       uut = ast_json_string_create("Hello, json");
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_STRING == ast_json_typeof(uut));
+       ast_test_validate(test, 0 == strcmp("Hello, json", ast_json_string_get(uut)));
+
+       uut_res = ast_json_string_set(uut, NULL);
+       ast_test_validate(test, -1 == uut_res);
+       ast_test_validate(test, 0 == strcmp("Hello, json", ast_json_string_get(uut)));
+
+       uut_res = ast_json_string_set(uut, "Not UTF-8 - \xff");
+       ast_test_validate(test, -1 == uut_res);
+       ast_test_validate(test, 0 == strcmp("Hello, json", ast_json_string_get(uut)));
+
+       uut_res = ast_json_string_set(uut, "Is UTF-8 - \xE2\x98\xBA");
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 0 == strcmp("Is UTF-8 - \xE2\x98\xBA", ast_json_string_get(uut)));
+
+       uut_res = ast_json_string_set(uut, "Goodbye, json");
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 0 == strcmp("Goodbye, json", ast_json_string_get(uut)));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_string_null)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "string_null";
+               info->category = "/main/json/";
+               info->summary = "JSON string NULL tests.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* NULL string */
+       uut = ast_json_string_create(NULL);
+       ast_test_validate(test, NULL == uut);
+
+       /* NULL JSON strings */
+       ast_test_validate(test, NULL == ast_json_string_create(NULL));
+       ast_test_validate(test, NULL == ast_json_string_get(NULL));
+       ast_test_validate(test, -1 == ast_json_string_set(NULL, "not null"));
+
+       /* string_value from non-string elements should return NULL */
+       ast_test_validate(test, NULL == ast_json_string_get(ast_json_null()));
+       ast_test_validate(test, NULL == ast_json_string_get(ast_json_false()));
+       ast_test_validate(test, NULL == ast_json_string_get(ast_json_true()));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_stringf)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "stringf";
+               info->category = "/main/json/";
+               info->summary = "Basic string formatting tests.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* NULL format string */
+       uut = ast_json_stringf(NULL);
+       ast_test_validate(test, NULL == uut);
+
+       /* Non-UTF-8 strings are invalid */
+       uut = ast_json_stringf("Not UTF-8 - %s", "\xff");
+       ast_test_validate(test, NULL == uut);
+
+       /* formatted string */
+       uut = ast_json_stringf("Hello, %s", "json");
+       expected = ast_json_string_create("Hello, json");
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_int)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "int";
+               info->category = "/main/json/";
+               info->summary = "Basic JSON integer tests.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* Integer tests */
+       uut = ast_json_integer_create(0);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_INTEGER == ast_json_typeof(uut));
+       ast_test_validate(test, 0 == ast_json_integer_get(uut));
+
+       uut_res = ast_json_integer_set(uut, 1);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 1 == ast_json_integer_get(uut));
+
+       uut_res = ast_json_integer_set(uut, -1);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, -1 == ast_json_integer_get(uut));
+
+       uut_res = ast_json_integer_set(uut, LLONG_MAX);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, LLONG_MAX == ast_json_integer_get(uut));
+
+       uut_res = ast_json_integer_set(uut, LLONG_MIN);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, LLONG_MIN == ast_json_integer_get(uut));
+
+       ast_json_unref(uut);
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_non_int)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "non_int";
+               info->category = "/main/json/";
+               info->summary = "Testing integer functions with non-integer types.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* Non-ints return 0 integer value */
+       ast_test_validate(test, 0 == ast_json_integer_get(ast_json_null()));
+       ast_test_validate(test, 0 == ast_json_integer_get(ast_json_true()));
+       ast_test_validate(test, 0 == ast_json_integer_get(ast_json_false()));
+
+       /* JSON NULL integers */
+       ast_test_validate(test, 0 == ast_json_integer_get(NULL));
+       ast_test_validate(test, -1 == ast_json_integer_set(NULL, 911));
+       ast_test_validate(test, 0 == ast_json_array_size(NULL));
+
+       /* No magical parsing of strings into ints */
+       uut = ast_json_string_create("314");
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, 0 == ast_json_integer_get(uut));
+
+       /* Or vice-versa */
+       ast_json_unref(uut);
+       uut = ast_json_integer_create(314);
+       ast_test_validate(test, NULL == ast_json_string_get(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_create)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_create";
+               info->category = "/main/json/";
+               info->summary = "Testing creating JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array creation */
+       uut = ast_json_array_create();
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_ARRAY == ast_json_typeof(uut));
+       ast_test_validate(test, 0 == ast_json_array_size(uut));
+
+       ast_json_unref(uut);
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_append)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_append";
+               info->category = "/main/json/";
+               info->summary = "Testing appending to JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array append */
+       uut = ast_json_array_create();
+       uut_res = ast_json_array_append(uut, ast_json_string_create("one"));
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 1 == ast_json_array_size(uut));
+       ast_test_validate(test, 0 == strcmp("one", ast_json_string_get(ast_json_array_get(uut, 0))));
+       /* index out of range */
+       ast_test_validate(test, NULL == ast_json_array_get(uut, 1));
+       ast_test_validate(test, NULL == ast_json_array_get(uut, -1));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_inset)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_insert";
+               info->category = "/main/json/";
+               info->summary = "Testing inserting into JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array insert */
+       uut = ast_json_pack("[s]", "one");
+       uut_res = ast_json_array_insert(uut, 0, ast_json_string_create("zero"));
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 2 == ast_json_array_size(uut));
+       ast_test_validate(test, 0 == strcmp("zero", ast_json_string_get(ast_json_array_get(uut, 0))));
+       ast_test_validate(test, 0 == strcmp("one", ast_json_string_get(ast_json_array_get(uut, 1))));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_set)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_set";
+               info->category = "/main/json/";
+               info->summary = "Testing setting a value in JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array set */
+       uut = ast_json_pack("[s, s]", "zero", "one");
+       uut_res = ast_json_array_set(uut, 1, ast_json_integer_create(1));
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 2 == ast_json_array_size(uut));
+       ast_test_validate(test, 0 == strcmp("zero", ast_json_string_get(ast_json_array_get(uut, 0))));
+       ast_test_validate(test, 1 == ast_json_integer_get(ast_json_array_get(uut, 1)));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_remove)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_remove";
+               info->category = "/main/json/";
+               info->summary = "Testing removing a value from JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array remove */
+       uut = ast_json_pack("[s, i]", "zero", 1);
+       expected = ast_json_pack("[i]", 1);
+       uut_res = ast_json_array_remove(uut, 0);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_clear)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_clear";
+               info->category = "/main/json/";
+               info->summary = "Testing clearing JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array clear */
+       uut = ast_json_pack("[s, s]", "zero", "one");
+       uut_res = ast_json_array_clear(uut);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 0 == ast_json_array_size(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_extend)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, tail, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_extend";
+               info->category = "/main/json/";
+               info->summary = "Testing extending JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array extending */
+       expected = ast_json_array_create();
+       ast_json_array_append(expected, ast_json_string_create("a"));
+       ast_json_array_append(expected, ast_json_string_create("b"));
+       ast_json_array_append(expected, ast_json_string_create("c"));
+       ast_json_array_append(expected, ast_json_integer_create(1));
+       ast_json_array_append(expected, ast_json_integer_create(2));
+       ast_json_array_append(expected, ast_json_integer_create(3));
+
+       uut = ast_json_array_create();
+       ast_json_array_append(uut, ast_json_string_create("a"));
+       ast_json_array_append(uut, ast_json_string_create("b"));
+       ast_json_array_append(uut, ast_json_string_create("c"));
+
+       tail = ast_json_array_create();
+       ast_json_array_append(tail, ast_json_integer_create(1));
+       ast_json_array_append(tail, ast_json_integer_create(2));
+       ast_json_array_append(tail, ast_json_integer_create(3));
+
+       uut_res = ast_json_array_extend(uut, tail);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       /* tail is preserved */
+       ast_test_validate(test, 3 == ast_json_array_size(tail));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_array_null)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "array_null";
+               info->category = "/main/json/";
+               info->summary = "Testing NULL conditions for JSON arrays.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* array NULL checks */
+       ast_test_validate(test, 0 == ast_json_array_size(NULL));
+       ast_test_validate(test, NULL == ast_json_array_get(NULL, 0));
+       ast_test_validate(test, -1 == ast_json_array_set(NULL, 0, ast_json_null()));
+       ast_test_validate(test, -1 == ast_json_array_append(NULL, ast_json_null()));
+       ast_test_validate(test, -1 == ast_json_array_insert(NULL, 0, ast_json_null()));
+       ast_test_validate(test, -1 == ast_json_array_remove(NULL, 0));
+       ast_test_validate(test, -1 == ast_json_array_clear(NULL));
+       uut = ast_json_array_create();
+       ast_test_validate(test, -1 == ast_json_array_extend(uut, NULL));
+       ast_test_validate(test, -1 == ast_json_array_extend(NULL, uut));
+       ast_test_validate(test, -1 == ast_json_array_extend(NULL, NULL));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_alloc)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_alloc";
+               info->category = "/main/json/";
+               info->summary = "Testing creating JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object allocation */
+       uut = ast_json_object_create();
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, AST_JSON_OBJECT == ast_json_typeof(uut));
+       ast_test_validate(test, 0 == ast_json_object_size(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_set)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_set";
+               info->category = "/main/json/";
+               info->summary = "Testing setting values in JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object set */
+       expected = ast_json_pack("{s: i, s: i, s: i}", "one", 1, "two", 2, "three", 3);
+       uut = ast_json_object_create();
+       uut_res = ast_json_object_set(uut, "one", ast_json_integer_create(1));
+       ast_test_validate(test, 0 == uut_res);
+       uut_res = ast_json_object_set(uut, "two", ast_json_integer_create(2));
+       ast_test_validate(test, 0 == uut_res);
+       uut_res = ast_json_object_set(uut, "three", ast_json_integer_create(3));
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       ast_test_validate(test, NULL == ast_json_object_get(uut, "dne"));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_set_overwrite)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_set_overwriting";
+               info->category = "/main/json/";
+               info->summary = "Testing changing values in JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object set existing */
+       uut = ast_json_pack("{s: i, s: i, s: i}", "one", 1, "two", 2, "three", 3);
+       uut_res = ast_json_object_set(uut, "two", ast_json_integer_create(-2));
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, -2 == ast_json_integer_get(ast_json_object_get(uut, "two")));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_get)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_get";
+               info->category = "/main/json/";
+               info->summary = "Testing getting values from JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object get */
+       uut = ast_json_pack("{s: i, s: i, s: i}", "one", 1, "two", 2, "three", 3);
+       ast_test_validate(test, 2 == ast_json_integer_get(ast_json_object_get(uut, "two")));
+       ast_test_validate(test, NULL == ast_json_object_get(uut, "dne"));
+       ast_test_validate(test, NULL == ast_json_object_get(uut, NULL));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_del)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_del";
+               info->category = "/main/json/";
+               info->summary = "Testing deleting values from JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object del */
+       expected = ast_json_object_create();
+       uut = ast_json_pack("{s: i}", "one", 1);
+       uut_res = ast_json_object_del(uut, "one");
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       uut_res = ast_json_object_del(uut, "dne");
+       ast_test_validate(test, -1 == uut_res);
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_clear)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_clear";
+               info->category = "/main/json/";
+               info->summary = "Testing clearing values from JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object clear */
+       uut = ast_json_object_create();
+       ast_json_object_set(uut, "one", ast_json_integer_create(1));
+       ast_json_object_set(uut, "two", ast_json_integer_create(2));
+       ast_json_object_set(uut, "three", ast_json_integer_create(3));
+       uut_res = ast_json_object_clear(uut);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, 0 == ast_json_object_size(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_merge_all)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, merge, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_alloc";
+               info->category = "/main/json/";
+               info->summary = "Testing merging JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object merging - all */
+       uut = ast_json_object_create();
+       ast_json_object_set(uut, "one", ast_json_integer_create(1));
+       ast_json_object_set(uut, "two", ast_json_integer_create(2));
+       ast_json_object_set(uut, "three", ast_json_integer_create(3));
+
+       merge = ast_json_object_create();
+       ast_json_object_set(merge, "three", ast_json_integer_create(-3));
+       ast_json_object_set(merge, "four", ast_json_integer_create(-4));
+       ast_json_object_set(merge, "five", ast_json_integer_create(-5));
+
+       expected = ast_json_object_create();
+       ast_json_object_set(expected, "one", ast_json_integer_create(1));
+       ast_json_object_set(expected, "two", ast_json_integer_create(2));
+       ast_json_object_set(expected, "three", ast_json_integer_create(-3));
+       ast_json_object_set(expected, "four", ast_json_integer_create(-4));
+       ast_json_object_set(expected, "five", ast_json_integer_create(-5));
+
+       uut_res = ast_json_object_update(uut, merge);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       /* merge object is untouched */
+       ast_test_validate(test, 3 == ast_json_object_size(merge));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_merge_existing)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, merge, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_alloc";
+               info->category = "/main/json/";
+               info->summary = "Testing merging JSON objects, updating only existing fields.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object merging - existing */
+       uut = ast_json_object_create();
+       ast_json_object_set(uut, "one", ast_json_integer_create(1));
+       ast_json_object_set(uut, "two", ast_json_integer_create(2));
+       ast_json_object_set(uut, "three", ast_json_integer_create(3));
+
+       merge = ast_json_object_create();
+       ast_json_object_set(merge, "three", ast_json_integer_create(-3));
+       ast_json_object_set(merge, "four", ast_json_integer_create(-4));
+       ast_json_object_set(merge, "five", ast_json_integer_create(-5));
+
+       expected = ast_json_object_create();
+       ast_json_object_set(expected, "one", ast_json_integer_create(1));
+       ast_json_object_set(expected, "two", ast_json_integer_create(2));
+       ast_json_object_set(expected, "three", ast_json_integer_create(-3));
+
+       uut_res = ast_json_object_update_existing(uut, merge);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       /* merge object is untouched */
+       ast_test_validate(test, 3 == ast_json_object_size(merge));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_merge_missing)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, merge, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_merge_missing";
+               info->category = "/main/json/";
+               info->summary = "Testing merging JSON objects, adding only missing fields.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* object merging - missing */
+       uut = ast_json_object_create();
+       ast_json_object_set(uut, "one", ast_json_integer_create(1));
+       ast_json_object_set(uut, "two", ast_json_integer_create(2));
+       ast_json_object_set(uut, "three", ast_json_integer_create(3));
+
+       merge = ast_json_object_create();
+       ast_json_object_set(merge, "three", ast_json_integer_create(-3));
+       ast_json_object_set(merge, "four", ast_json_integer_create(-4));
+       ast_json_object_set(merge, "five", ast_json_integer_create(-5));
+
+       expected = ast_json_object_create();
+       ast_json_object_set(expected, "one", ast_json_integer_create(1));
+       ast_json_object_set(expected, "two", ast_json_integer_create(2));
+       ast_json_object_set(expected, "three", ast_json_integer_create(3));
+       ast_json_object_set(expected, "four", ast_json_integer_create(-4));
+       ast_json_object_set(expected, "five", ast_json_integer_create(-5));
+
+       uut_res = ast_json_object_update_missing(uut, merge);
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       /* merge object is untouched */
+       ast_test_validate(test, 3 == ast_json_object_size(merge));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_null)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_null";
+               info->category = "/main/json/";
+               info->summary = "Testing JSON object NULL behavior.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* Object NULL testing */
+       ast_test_validate(test, 0 == ast_json_object_size(NULL));
+       ast_test_validate(test, NULL == ast_json_object_get(NULL, "not null"));
+       ast_test_validate(test, -1 == ast_json_object_set(NULL, "not null", ast_json_null()));
+       ast_test_validate(test, -1 == ast_json_object_del(NULL, "not null"));
+       ast_test_validate(test, -1 == ast_json_object_clear(NULL));
+       uut = ast_json_object_create();
+       ast_test_validate(test, -1 == ast_json_object_update(NULL, uut));
+       ast_test_validate(test, -1 == ast_json_object_update(uut, NULL));
+       ast_test_validate(test, -1 == ast_json_object_update(NULL, NULL));
+       ast_test_validate(test, -1 == ast_json_object_update_existing(NULL, uut));
+       ast_test_validate(test, -1 == ast_json_object_update_existing(uut, NULL));
+       ast_test_validate(test, -1 == ast_json_object_update_existing(NULL, NULL));
+       ast_test_validate(test, -1 == ast_json_object_update_missing(NULL, uut));
+       ast_test_validate(test, -1 == ast_json_object_update_missing(uut, NULL));
+       ast_test_validate(test, -1 == ast_json_object_update_missing(NULL, NULL));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_iter)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       struct ast_json_iter *iter;
+       int count;
+       int uut_res;
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_iter";
+               info->category = "/main/json/";
+               info->summary = "Testing iterating through JSON objects.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* Object iterator testing */
+       uut = ast_json_pack("{s: i, s: i, s: i, s: i, s: i}", "one", 1, "two", 2, "three", 3, "four", 4, "five", 5);
+
+       /* Iterate through the object; be aware that order isn't specified */
+       iter = ast_json_object_iter(uut);
+       ast_test_validate(test, NULL != iter);
+       count = 0;
+       while (NULL != iter) {
+               if (0 == strcmp("one", ast_json_object_iter_key(iter))) {
+                       ast_test_validate(test, 1 == ast_json_integer_get(ast_json_object_iter_value(iter)));
+               } else if (0 == strcmp("two", ast_json_object_iter_key(iter))) {
+                       ast_test_validate(test, 2 == ast_json_integer_get(ast_json_object_iter_value(iter)));
+               } else if (0 == strcmp("three", ast_json_object_iter_key(iter))) {
+                       ast_test_validate(test, 3 == ast_json_integer_get(ast_json_object_iter_value(iter)));
+               } else if (0 == strcmp("four", ast_json_object_iter_key(iter))) {
+                       ast_test_validate(test, 4 == ast_json_integer_get(ast_json_object_iter_value(iter)));
+               } else if (0 == strcmp("five", ast_json_object_iter_key(iter))) {
+                       ast_test_validate(test, 5 == ast_json_integer_get(ast_json_object_iter_value(iter)));
+               } else {
+                       /* Unexpected key */
+                       ast_test_validate(test, 0);
+               }
+               iter = ast_json_object_iter_next(uut, iter);
+               ++count;
+       }
+       ast_test_validate(test, 5 == count);
+
+       /* iterator non-existing key */
+       iter = ast_json_object_iter_at(uut, "dne");
+       ast_test_validate(test, NULL == iter);
+
+       /* iterator specific key */
+       iter = ast_json_object_iter_at(uut, "three");
+       ast_test_validate(test, NULL != iter);
+       ast_test_validate(test, 3 == ast_json_integer_get(ast_json_object_iter_value(iter)));
+
+       /* set via iter */
+       iter = ast_json_object_iter_at(uut, "three");
+       uut_res = ast_json_object_iter_set(uut, iter, ast_json_integer_create(-3));
+       ast_test_validate(test, 0 == uut_res);
+       ast_test_validate(test, -3 == ast_json_integer_get(ast_json_object_get(uut, "three")));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_object_iter_null)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_iter_null";
+               info->category = "/main/json/";
+               info->summary = "Testing JSON object iterator NULL testings.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* iterator NULL tests */
+       uut = ast_json_object_create();
+       ast_test_validate(test, NULL == ast_json_object_iter(NULL));
+       ast_test_validate(test, NULL == ast_json_object_iter_at(NULL, "not null"));
+       ast_test_validate(test, NULL == ast_json_object_iter_next(NULL, NULL));
+       ast_test_validate(test, NULL == ast_json_object_iter_next(uut, NULL));
+       ast_test_validate(test, NULL == ast_json_object_iter_key(NULL));
+       ast_test_validate(test, NULL == ast_json_object_iter_value(NULL));
+       ast_test_validate(test, -1 == ast_json_object_iter_set(NULL, NULL, ast_json_null()));
+       ast_test_validate(test, -1 == ast_json_object_iter_set(uut, NULL, ast_json_null()));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_dump_load_string)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       RAII_VAR(char *, str, NULL, json_debug_free);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "dump_load_string";
+               info->category = "/main/json/";
+               info->summary = "Testing dumping strings from JSON.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+       expected = ast_json_pack("{ s: i }", "one", 1);
+       str = ast_json_dump_string(expected);
+       ast_test_validate(test, NULL != str);
+       uut = ast_json_load_string(str, NULL);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+
+       /* dump_string NULL */
+       ast_test_validate(test, NULL == ast_json_dump_string(NULL));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_dump_load_str)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       RAII_VAR(struct ast_str *, astr, NULL, ast_free);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "dump_load_str";
+               info->category = "/main/json/";
+               info->summary = "Testing dumping ast_str from JSON.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* dump/load ast_str */
+       expected = ast_json_pack("{ s: i }", "one", 1);
+       astr = ast_str_create(1); /* should expand to hold output */
+       uut_res = ast_json_dump_str(expected, &astr);
+       ast_test_validate(test, 0 == uut_res);
+       uut = ast_json_load_str(astr, NULL);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_dump_str_fail)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       struct ast_str *astr;
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "dump_str_fail";
+               info->category = "/main/json/";
+               info->summary = "Testing dumping to ast_str when it can't grow.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* dump ast_str growth failure */
+       expected = ast_json_pack("{ s: i }", "one", 1);
+       astr = ast_str_alloca(1); /* cannot grow */
+       uut_res = ast_json_dump_str(expected, &astr);
+       ast_test_validate(test, 0 != uut_res);
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_load_buffer)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       const char *str;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "load_buffer";
+               info->category = "/main/json/";
+               info->summary = "Testing loading JSON from buffer.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* load buffer */
+       str = "{ \"one\": 1 } trailing garbage";
+       uut = ast_json_load_string(str, NULL);
+       ast_test_validate(test, NULL == uut);
+       uut = ast_json_load_buf(str, strlen("{ \"one\": 1 }"), NULL);
+       ast_test_validate(test, NULL != uut);
+
+       return AST_TEST_PASS;
+}
+
+/*! \brief \a fclose isn't NULL safe. */
+static int safe_fclose(FILE *f)
+{
+       if (f) {
+               return fclose(f);
+       }
+       return 0;
+}
+
+AST_TEST_DEFINE(json_test_dump_load_file)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       RAII_VAR(char *, filename, NULL, free);
+       RAII_VAR(FILE *, file, NULL, safe_fclose);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "dump_load_file";
+               info->category = "/main/json/";
+               info->summary = "Testing dumping/loading JSON to/from file by FILE *.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* dump/load file */
+       expected = ast_json_pack("{ s: i }", "one", 1);
+       filename = tempnam(NULL, "ast-json");
+       file = fopen(filename, "w");
+       uut_res = ast_json_dump_file(expected, file);
+       ast_test_validate(test, 0 == uut_res);
+       fclose(file);
+       file = fopen(filename, "r");
+       uut = ast_json_load_file(file, NULL);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_dump_load_new_file)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+       RAII_VAR(char *, filename, NULL, free);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "dump_load_new_file";
+               info->category = "/main/json/";
+               info->summary = "Testing dumping/load JSON to/from file by filename.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* dump/load filename */
+       expected = ast_json_pack("{ s: i }", "one", 1);
+       filename = tempnam(NULL, "ast-json");
+       uut_res = ast_json_dump_new_file(expected, filename);
+       ast_test_validate(test, 0 == uut_res);
+       uut = ast_json_load_new_file(filename, NULL);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_dump_load_null)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(char *, filename, NULL, free);
+       RAII_VAR(FILE *, file, NULL, safe_fclose);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "dump_load_null";
+               info->category = "/main/json/";
+               info->summary = "Testing NULL handling of dump/load functions.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* dump/load NULL tests */
+       uut = ast_json_load_string("{ \"one\": 1 }", NULL);
+       ast_test_validate(test, NULL != uut);
+       filename = tempnam(NULL, "ast-json");
+       file = fopen(filename, "w");
+       ast_test_validate(test, NULL == ast_json_dump_string(NULL));
+       ast_test_validate(test, -1 == ast_json_dump_file(NULL, file));
+       ast_test_validate(test, -1 == ast_json_dump_file(uut, NULL));
+       ast_test_validate(test, -1 == ast_json_dump_file(NULL, NULL));
+       ast_test_validate(test, -1 == ast_json_dump_new_file(uut, NULL));
+       ast_test_validate(test, -1 == ast_json_dump_new_file(NULL, filename));
+       ast_test_validate(test, -1 == ast_json_dump_new_file(NULL, NULL));
+       ast_test_validate(test, NULL == ast_json_load_string(NULL, NULL));
+       ast_test_validate(test, NULL == ast_json_load_buf(NULL, 0, NULL));
+       ast_test_validate(test, NULL == ast_json_load_file(NULL, NULL));
+       ast_test_validate(test, NULL == ast_json_load_new_file(NULL, NULL));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_parse_errors)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "parse_errors";
+               info->category = "/main/json/";
+               info->summary = "Testing various parse errors.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* parse errors */
+       ast_test_validate(test, NULL == ast_json_load_string("'singleton'", NULL));
+       ast_test_validate(test, NULL == ast_json_load_string("{ no value }", NULL));
+       ast_test_validate(test, NULL == ast_json_load_string("{ 'no': 'curly' ", NULL));
+       ast_test_validate(test, NULL == ast_json_load_string("[ 'no', 'square'", NULL));
+       ast_test_validate(test, NULL == ast_json_load_string("{ 1: 'int key' }", NULL));
+       ast_test_validate(test, NULL == ast_json_load_string("", NULL));
+       ast_test_validate(test, NULL == ast_json_load_string("{ 'missing' 'colon' }", NULL));
+       ast_test_validate(test, NULL == ast_json_load_string("[ 'missing' 'comma' ]", NULL));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_pack)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "pack";
+               info->category = "/main/json/";
+               info->summary = "Testing json_pack function.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* pack test */
+       expected = ast_json_array_create();
+       ast_json_array_append(expected, ast_json_array_create());
+       ast_json_array_append(expected, ast_json_object_create());
+       ast_json_array_append(ast_json_array_get(expected, 0), ast_json_integer_create(1));
+       ast_json_array_append(ast_json_array_get(expected, 0), ast_json_integer_create(2));
+       ast_json_object_set(ast_json_array_get(expected, 1), "cool", ast_json_true());
+       uut = ast_json_pack("[[i,i],{s:b}]", 1, 2, "cool", 1);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_pack_errors)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "object_alloc";
+               info->category = "/main/json/";
+               info->summary = "Testing json_pack failure conditions.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* pack errors */
+       ast_test_validate(test, NULL == ast_json_pack(NULL));
+       ast_test_validate(test, NULL == ast_json_pack("{s:i", "no curly", 911));
+       ast_test_validate(test, NULL == ast_json_pack("[s, s", "no", "square"));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_copy)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "copy";
+               info->category = "/main/json/";
+               info->summary = "Testing copying JSON.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* copy test */
+       expected = ast_json_pack("{s: {s: i}}", "outer", "inner", 8675309);
+       uut = ast_json_copy(expected);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       ast_test_validate(test, ast_json_object_get(expected, "outer") == ast_json_object_get(uut, "outer"));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_deep_copy)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, expected, NULL, ast_json_unref);
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "deep_copy";
+               info->category = "/main/json/";
+               info->summary = "Testing deep copying of JSON.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* deep copy test */
+       expected = ast_json_pack("{s: {s: i}}", "outer", "inner", 8675309);
+       uut = ast_json_deep_copy(expected);
+       ast_test_validate(test, NULL != uut);
+       ast_test_validate(test, ast_json_equal(expected, uut));
+       ast_test_validate(test, ast_json_object_get(expected, "outer") != ast_json_object_get(uut, "outer"));
+       /* Changing the inner value of one should not change the other */
+       ast_json_integer_set(ast_json_object_get(ast_json_object_get(uut, "outer"), "inner"), 411);
+       ast_test_validate(test, !ast_json_equal(expected, uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_copy_null)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "copy_null";
+               info->category = "/main/json/";
+               info->summary = "Testing NULL handling of copy functions.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* copy NULL */
+       ast_test_validate(test, NULL == ast_json_copy(NULL));
+       ast_test_validate(test, NULL == ast_json_deep_copy(NULL));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_circular_object)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "circular_object";
+               info->category = "/main/json/";
+               info->summary = "Object cannot be added to itself.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* circular reference testing */
+       /* Cannot add self */
+       uut = ast_json_object_create();
+       uut_res = ast_json_object_set(uut, "myself", uut);
+       ast_test_validate(test, -1 == uut_res);
+       ast_test_validate(test, 0 == ast_json_object_size(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_circular_array)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "circular_array";
+               info->category = "/main/json/";
+               info->summary = "Array cannot be added to itself.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       uut = ast_json_array_create();
+       uut_res = ast_json_object_set(uut, "myself", uut);
+       ast_test_validate(test, -1 == uut_res);
+       ast_test_validate(test, 0 == ast_json_array_size(uut));
+
+       return AST_TEST_PASS;
+}
+
+AST_TEST_DEFINE(json_test_clever_circle)
+{
+       RAII_VAR(void *, alloc_debug, json_test_init(test), json_test_finish);
+       RAII_VAR(struct ast_json *, uut, NULL, ast_json_unref);
+       RAII_VAR(struct ast_json *, inner_child, NULL, ast_json_unref);
+       RAII_VAR(char *, str, NULL, json_debug_free);
+       int uut_res;
+
+       switch (cmd) {
+       case TEST_INIT:
+               info->name = "clever_circle";
+               info->category = "/main/json/";
+               info->summary = "JSON with circular references cannot be encoded.";
+               info->description = "Test JSON abstraction library.";
+               return AST_TEST_NOT_RUN;
+       case TEST_EXECUTE:
+               break;
+       }
+
+       /* can add to self if you're clever enough, but it should not encode */
+       uut = ast_json_object_create();
+       inner_child = ast_json_object_create();
+       uut_res = ast_json_object_set(uut, "inner_child", ast_json_ref(inner_child));   /* incref to keep a reference */
+       ast_test_validate(test, 0 == uut_res);
+       uut_res = ast_json_object_set(inner_child, "parent", ast_json_ref(uut));   /* incref to keep a reference */
+       ast_test_validate(test, 0 == uut_res);
+       str = ast_json_dump_string(uut);
+       ast_test_validate(test, NULL == str);
+       /* Circular refs screw up reference counting, so break the cycle */
+       ast_json_object_clear(inner_child);
+
+       return AST_TEST_PASS;
+}
+
+static int unload_module(void)
+{
+       AST_TEST_UNREGISTER(json_test_false);
+       AST_TEST_UNREGISTER(json_test_true);
+       AST_TEST_UNREGISTER(json_test_bool0);
+       AST_TEST_UNREGISTER(json_test_bool1);
+       AST_TEST_UNREGISTER(json_test_null);
+       AST_TEST_UNREGISTER(json_test_null_val);
+       AST_TEST_UNREGISTER(json_test_string);
+       AST_TEST_UNREGISTER(json_test_string_null);
+       AST_TEST_UNREGISTER(json_test_stringf);
+       AST_TEST_UNREGISTER(json_test_int);
+       AST_TEST_UNREGISTER(json_test_non_int);
+       AST_TEST_UNREGISTER(json_test_array_create);
+       AST_TEST_UNREGISTER(json_test_array_append);
+       AST_TEST_UNREGISTER(json_test_array_inset);
+       AST_TEST_UNREGISTER(json_test_array_set);
+       AST_TEST_UNREGISTER(json_test_array_remove);
+       AST_TEST_UNREGISTER(json_test_array_clear);
+       AST_TEST_UNREGISTER(json_test_array_extend);
+       AST_TEST_UNREGISTER(json_test_array_null);
+       AST_TEST_UNREGISTER(json_test_object_alloc);
+       AST_TEST_UNREGISTER(json_test_object_set);
+       AST_TEST_UNREGISTER(json_test_object_set_overwrite);
+       AST_TEST_UNREGISTER(json_test_object_get);
+       AST_TEST_UNREGISTER(json_test_object_del);
+       AST_TEST_UNREGISTER(json_test_object_clear);
+       AST_TEST_UNREGISTER(json_test_object_merge_all);
+       AST_TEST_UNREGISTER(json_test_object_merge_existing);
+       AST_TEST_UNREGISTER(json_test_object_merge_missing);
+       AST_TEST_UNREGISTER(json_test_object_null);
+       AST_TEST_UNREGISTER(json_test_object_iter);
+       AST_TEST_UNREGISTER(json_test_object_iter_null);
+       AST_TEST_UNREGISTER(json_test_dump_load_string);
+       AST_TEST_UNREGISTER(json_test_dump_load_str);
+       AST_TEST_UNREGISTER(json_test_dump_str_fail);
+       AST_TEST_UNREGISTER(json_test_load_buffer);
+       AST_TEST_UNREGISTER(json_test_dump_load_file);
+       AST_TEST_UNREGISTER(json_test_dump_load_new_file);
+       AST_TEST_UNREGISTER(json_test_dump_load_null);
+       AST_TEST_UNREGISTER(json_test_parse_errors);
+       AST_TEST_UNREGISTER(json_test_pack);
+       AST_TEST_UNREGISTER(json_test_pack_errors);
+       AST_TEST_UNREGISTER(json_test_copy);
+       AST_TEST_UNREGISTER(json_test_deep_copy);
+       AST_TEST_UNREGISTER(json_test_copy_null);
+       AST_TEST_UNREGISTER(json_test_circular_object);
+       AST_TEST_UNREGISTER(json_test_circular_array);
+       AST_TEST_UNREGISTER(json_test_clever_circle);
+       return 0;
+}
+
+static int load_module(void)
+{
+       AST_TEST_REGISTER(json_test_false);
+       AST_TEST_REGISTER(json_test_true);
+       AST_TEST_REGISTER(json_test_bool0);
+       AST_TEST_REGISTER(json_test_bool1);
+       AST_TEST_REGISTER(json_test_null);
+       AST_TEST_REGISTER(json_test_null_val);
+       AST_TEST_REGISTER(json_test_string);
+       AST_TEST_REGISTER(json_test_string_null);
+       AST_TEST_REGISTER(json_test_stringf);
+       AST_TEST_REGISTER(json_test_int);
+       AST_TEST_REGISTER(json_test_non_int);
+       AST_TEST_REGISTER(json_test_array_create);
+       AST_TEST_REGISTER(json_test_array_append);
+       AST_TEST_REGISTER(json_test_array_inset);
+       AST_TEST_REGISTER(json_test_array_set);
+       AST_TEST_REGISTER(json_test_array_remove);
+       AST_TEST_REGISTER(json_test_array_clear);
+       AST_TEST_REGISTER(json_test_array_extend);
+       AST_TEST_REGISTER(json_test_array_null);
+       AST_TEST_REGISTER(json_test_object_alloc);
+       AST_TEST_REGISTER(json_test_object_set);
+       AST_TEST_REGISTER(json_test_object_set_overwrite);
+       AST_TEST_REGISTER(json_test_object_get);
+       AST_TEST_REGISTER(json_test_object_del);
+       AST_TEST_REGISTER(json_test_object_clear);
+       AST_TEST_REGISTER(json_test_object_merge_all);
+       AST_TEST_REGISTER(json_test_object_merge_existing);
+       AST_TEST_REGISTER(json_test_object_merge_missing);
+       AST_TEST_REGISTER(json_test_object_null);
+       AST_TEST_REGISTER(json_test_object_iter);
+       AST_TEST_REGISTER(json_test_object_iter_null);
+       AST_TEST_REGISTER(json_test_dump_load_string);
+       AST_TEST_REGISTER(json_test_dump_load_str);
+       AST_TEST_REGISTER(json_test_dump_str_fail);
+       AST_TEST_REGISTER(json_test_load_buffer);
+       AST_TEST_REGISTER(json_test_dump_load_file);
+       AST_TEST_REGISTER(json_test_dump_load_new_file);
+       AST_TEST_REGISTER(json_test_dump_load_null);
+       AST_TEST_REGISTER(json_test_parse_errors);
+       AST_TEST_REGISTER(json_test_pack);
+       AST_TEST_REGISTER(json_test_pack_errors);
+       AST_TEST_REGISTER(json_test_copy);
+       AST_TEST_REGISTER(json_test_deep_copy);
+       AST_TEST_REGISTER(json_test_copy_null);
+       AST_TEST_REGISTER(json_test_circular_object);
+       AST_TEST_REGISTER(json_test_circular_array);
+       AST_TEST_REGISTER(json_test_clever_circle);
+       return AST_MODULE_LOAD_SUCCESS;
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "JSON testing.");