Merge pull request #226 from DaveGamble/boolean_add

Convert cJSON_Add..ToObject macros into functions with return values

cJSON.c

@@ -1844,14 +1844,13 @@ static cJSON *create_reference(const cJSON *item, const internal_hooks * const h
     return reference;
 }
 
-/* Add item to array/object. */
+static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
-CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item)
 {
     cJSON *child = NULL;
 
     if ((item == NULL) || (array == NULL))
     {
-        return;
+        return false;
     }
 
     child = array->child;
@@ -1870,19 +1869,14 @@ CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item)
         }
         suffix_object(child, item);
     }
+
+    return true;
 }
 
-CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
+/* Add item to array/object. */
+CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item)
 {
-    if (item == NULL)
+    add_item_to_array(array, item);
-    {
-        return;
-    }
-
-    /* call cJSON_AddItemToObjectCS for code reuse */
-    cJSON_AddItemToObjectCS(object, (char*)cJSON_strdup((const unsigned char*)string, &global_hooks), item);
-    /* remove cJSON_StringIsConst flag */
-    item->type &= ~cJSON_StringIsConst;
 }
 
 #if defined(__clang__) || (defined(__GNUC__)  && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5))))
@@ -1900,20 +1894,48 @@ static void* cast_away_const(const void* string)
     #pragma GCC diagnostic pop
 #endif
 
+
+static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)
+{
+    if ((object == NULL) || (string == NULL) || (item == NULL))
+    {
+        return false;
+    }
+
+    if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
+    {
+        hooks->deallocate(item->string);
+    }
+
+    if (constant_key)
+    {
+        item->string = (char*)cast_away_const(string);
+        item->type |= cJSON_StringIsConst;
+    }
+    else
+    {
+        char *key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
+        if (key == NULL)
+        {
+            return false;
+        }
+
+        item->string = key;
+        item->type &= ~cJSON_StringIsConst;
+    }
+
+    return add_item_to_array(object, item);
+}
+
+CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
+{
+    add_item_to_object(object, string, item, &global_hooks, false);
+}
+
 /* Add an item to an object with constant string as key */
 CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
 {
-    if ((item == NULL) || (string == NULL))
+    add_item_to_object(object, string, item, &global_hooks, true);
-    {
-        return;
-    }
-    if (!(item->type & cJSON_StringIsConst) && item->string)
-    {
-        global_hooks.deallocate(item->string);
-    }
-    item->string = (char*)cast_away_const(string);
-    item->type |= cJSON_StringIsConst;
-    cJSON_AddItemToArray(object, item);
 }
 
 CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
@@ -1923,7 +1945,7 @@ CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
         return;
     }
 
-    cJSON_AddItemToArray(array, create_reference(item, &global_hooks));
+    add_item_to_array(array, create_reference(item, &global_hooks));
 }
 
 CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)
@@ -1933,7 +1955,115 @@ CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON *object, const char *str
         return;
     }
 
-    cJSON_AddItemToObject(object, string, create_reference(item, &global_hooks));
+    add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false);
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name)
+{
+    cJSON *null = cJSON_CreateNull();
+    if (add_item_to_object(object, name, null, &global_hooks, false))
+    {
+        return null;
+    }
+
+    cJSON_Delete(null);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name)
+{
+    cJSON *true_item = cJSON_CreateTrue();
+    if (add_item_to_object(object, name, true_item, &global_hooks, false))
+    {
+        return true_item;
+    }
+
+    cJSON_Delete(true_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name)
+{
+    cJSON *false_item = cJSON_CreateFalse();
+    if (add_item_to_object(object, name, false_item, &global_hooks, false))
+    {
+        return false_item;
+    }
+
+    cJSON_Delete(false_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean)
+{
+    cJSON *bool_item = cJSON_CreateBool(boolean);
+    if (add_item_to_object(object, name, bool_item, &global_hooks, false))
+    {
+        return bool_item;
+    }
+
+    cJSON_Delete(bool_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number)
+{
+    cJSON *number_item = cJSON_CreateNumber(number);
+    if (add_item_to_object(object, name, number_item, &global_hooks, false))
+    {
+        return number_item;
+    }
+
+    cJSON_Delete(number_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string)
+{
+    cJSON *string_item = cJSON_CreateString(string);
+    if (add_item_to_object(object, name, string_item, &global_hooks, false))
+    {
+        return string_item;
+    }
+
+    cJSON_Delete(string_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw)
+{
+    cJSON *raw_item = cJSON_CreateRaw(raw);
+    if (add_item_to_object(object, name, raw_item, &global_hooks, false))
+    {
+        return raw_item;
+    }
+
+    cJSON_Delete(raw_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name)
+{
+    cJSON *object_item = cJSON_CreateObject();
+    if (add_item_to_object(object, name, object_item, &global_hooks, false))
+    {
+        return object_item;
+    }
+
+    cJSON_Delete(object_item);
+    return NULL;
+}
+
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name)
+{
+    cJSON *array = cJSON_CreateArray();
+    if (add_item_to_object(object, name, array, &global_hooks, false))
+    {
+        return array;
+    }
+
+    cJSON_Delete(array);
+    return NULL;
 }
 
 CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item)
@@ -2018,7 +2148,7 @@ CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newit
     after_inserted = get_array_item(array, (size_t)which);
     if (after_inserted == NULL)
     {
-        cJSON_AddItemToArray(array, newitem);
+        add_item_to_array(array, newitem);
         return;
     }
 

cJSON.h

@@ -245,14 +245,17 @@ CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * cons
 
 CJSON_PUBLIC(void) cJSON_Minify(char *json);
 
-/* Macros for creating things quickly. */
+/* Helper functions for creating and adding items to an object at the same time.
-#define cJSON_AddNullToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateNull())
+ * They return the added item or NULL on failure. */
-#define cJSON_AddTrueToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
-#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
-#define cJSON_AddBoolToObject(object,name,b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
-#define cJSON_AddNumberToObject(object,name,n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
-#define cJSON_AddStringToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
-#define cJSON_AddRawToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateRaw(s))
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
 
 /* When assigning an integer value, it needs to be propagated to valuedouble too. */
 #define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))

tests/CMakeLists.txt

@@ -55,6 +55,7 @@ if(ENABLE_CJSON_TEST)
         misc_tests
         parse_with_opts
         compare_tests
+        cjson_add
     )
 
     option(ENABLE_VALGRIND OFF "Enable the valgrind memory checker for the tests.")

tests/cjson_add.c

@@ -0,0 +1,416 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "unity/examples/unity_config.h"
+#include "unity/src/unity.h"
+#include "common.h"
+
+static void *failing_malloc(size_t size)
+{
+    (void)size;
+    return NULL;
+}
+
+static cJSON_Hooks failing_hooks = {
+    failing_malloc,
+    free
+};
+
+static void cjson_add_null_should_add_null(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *null = NULL;
+
+    cJSON_AddNullToObject(root, "null");
+
+    TEST_ASSERT_NOT_NULL(null = cJSON_GetObjectItemCaseSensitive(root, "null"));
+    TEST_ASSERT_EQUAL_INT(null->type, cJSON_NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_null_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddNullToObject(NULL, "null"));
+    TEST_ASSERT_NULL(cJSON_AddNullToObject(root, NULL));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_null_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddNullToObject(root, "null"));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_true_should_add_true(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *true_item = NULL;
+
+    cJSON_AddTrueToObject(root, "true");
+
+    TEST_ASSERT_NOT_NULL(true_item = cJSON_GetObjectItemCaseSensitive(root, "true"));
+    TEST_ASSERT_EQUAL_INT(true_item->type, cJSON_True);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_true_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddTrueToObject(NULL, "true"));
+    TEST_ASSERT_NULL(cJSON_AddTrueToObject(root, NULL));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_true_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddTrueToObject(root, "true"));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_false_should_add_false(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *false_item = NULL;
+
+    cJSON_AddFalseToObject(root, "false");
+
+    TEST_ASSERT_NOT_NULL(false_item = cJSON_GetObjectItemCaseSensitive(root, "false"));
+    TEST_ASSERT_EQUAL_INT(false_item->type, cJSON_False);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_false_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddFalseToObject(NULL, "false"));
+    TEST_ASSERT_NULL(cJSON_AddFalseToObject(root, NULL));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_false_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddFalseToObject(root, "false"));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_bool_should_add_bool(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *true_item = NULL;
+    cJSON *false_item = NULL;
+
+    /* true */
+    cJSON_AddBoolToObject(root, "true", true);
+    TEST_ASSERT_NOT_NULL(true_item = cJSON_GetObjectItemCaseSensitive(root, "true"));
+    TEST_ASSERT_EQUAL_INT(true_item->type, cJSON_True);
+
+    /* false */
+    cJSON_AddBoolToObject(root, "false", false);
+    TEST_ASSERT_NOT_NULL(false_item = cJSON_GetObjectItemCaseSensitive(root, "false"));
+    TEST_ASSERT_EQUAL_INT(false_item->type, cJSON_False);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_bool_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddBoolToObject(NULL, "false", false));
+    TEST_ASSERT_NULL(cJSON_AddBoolToObject(root, NULL, false));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_bool_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddBoolToObject(root, "false", false));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_number_should_add_number(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *number = NULL;
+
+    cJSON_AddNumberToObject(root, "number", 42);
+
+    TEST_ASSERT_NOT_NULL(number = cJSON_GetObjectItemCaseSensitive(root, "number"));
+
+    TEST_ASSERT_EQUAL_INT(number->type, cJSON_Number);
+    TEST_ASSERT_EQUAL_DOUBLE(number->valuedouble, 42);
+    TEST_ASSERT_EQUAL_INT(number->valueint, 42);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_number_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddNumberToObject(NULL, "number", 42));
+    TEST_ASSERT_NULL(cJSON_AddNumberToObject(root, NULL, 42));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_number_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddNumberToObject(root, "number", 42));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_string_should_add_string(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *string = NULL;
+
+    cJSON_AddStringToObject(root, "string", "Hello World!");
+
+    TEST_ASSERT_NOT_NULL(string = cJSON_GetObjectItemCaseSensitive(root, "string"));
+    TEST_ASSERT_EQUAL_INT(string->type, cJSON_String);
+    TEST_ASSERT_EQUAL_STRING(string->valuestring, "Hello World!");
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_string_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddStringToObject(NULL, "string", "string"));
+    TEST_ASSERT_NULL(cJSON_AddStringToObject(root, NULL, "string"));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_string_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddStringToObject(root, "string", "string"));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_raw_should_add_raw(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *raw = NULL;
+
+    cJSON_AddRawToObject(root, "raw", "{}");
+
+    TEST_ASSERT_NOT_NULL(raw = cJSON_GetObjectItemCaseSensitive(root, "raw"));
+    TEST_ASSERT_EQUAL_INT(raw->type, cJSON_Raw);
+    TEST_ASSERT_EQUAL_STRING(raw->valuestring, "{}");
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_raw_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddRawToObject(NULL, "raw", "{}"));
+    TEST_ASSERT_NULL(cJSON_AddRawToObject(root, NULL, "{}"));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_raw_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddRawToObject(root, "raw", "{}"));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cJSON_add_object_should_add_object(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *object = NULL;
+
+    cJSON_AddObjectToObject(root, "object");
+    TEST_ASSERT_NOT_NULL(object = cJSON_GetObjectItemCaseSensitive(root, "object"));
+    TEST_ASSERT_EQUAL_INT(object->type, cJSON_Object);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_object_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddObjectToObject(NULL, "object"));
+    TEST_ASSERT_NULL(cJSON_AddObjectToObject(root, NULL));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_object_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddObjectToObject(root, "object"));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+static void cJSON_add_array_should_add_array(void)
+{
+    cJSON *root = cJSON_CreateObject();
+    cJSON *array = NULL;
+
+    cJSON_AddArrayToObject(root, "array");
+    TEST_ASSERT_NOT_NULL(array = cJSON_GetObjectItemCaseSensitive(root, "array"));
+    TEST_ASSERT_EQUAL_INT(array->type, cJSON_Array);
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_array_should_fail_with_null_pointers(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    TEST_ASSERT_NULL(cJSON_AddArrayToObject(NULL, "array"));
+    TEST_ASSERT_NULL(cJSON_AddArrayToObject(root, NULL));
+
+    cJSON_Delete(root);
+}
+
+static void cjson_add_array_should_fail_on_allocation_failure(void)
+{
+    cJSON *root = cJSON_CreateObject();
+
+    cJSON_InitHooks(&failing_hooks);
+
+    TEST_ASSERT_NULL(cJSON_AddArrayToObject(root, "array"));
+
+    cJSON_InitHooks(NULL);
+
+    cJSON_Delete(root);
+}
+
+int main(void)
+{
+    UNITY_BEGIN();
+
+    RUN_TEST(cjson_add_null_should_add_null);
+    RUN_TEST(cjson_add_null_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_null_should_fail_on_allocation_failure);
+
+    RUN_TEST(cjson_add_true_should_add_true);
+    RUN_TEST(cjson_add_true_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_true_should_fail_on_allocation_failure);
+
+    RUN_TEST(cjson_add_false_should_add_false);
+    RUN_TEST(cjson_add_false_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_false_should_fail_on_allocation_failure);
+
+    RUN_TEST(cjson_add_bool_should_add_bool);
+    RUN_TEST(cjson_add_bool_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_bool_should_fail_on_allocation_failure);
+
+    RUN_TEST(cjson_add_number_should_add_number);
+    RUN_TEST(cjson_add_number_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_number_should_fail_on_allocation_failure);
+
+    RUN_TEST(cjson_add_string_should_add_string);
+    RUN_TEST(cjson_add_string_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_string_should_fail_on_allocation_failure);
+
+    RUN_TEST(cjson_add_raw_should_add_raw);
+    RUN_TEST(cjson_add_raw_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_raw_should_fail_on_allocation_failure);
+
+    RUN_TEST(cJSON_add_object_should_add_object);
+    RUN_TEST(cjson_add_object_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_object_should_fail_on_allocation_failure);
+
+    RUN_TEST(cJSON_add_array_should_add_array);
+    RUN_TEST(cjson_add_array_should_fail_with_null_pointers);
+    RUN_TEST(cjson_add_array_should_fail_on_allocation_failure);
+
+    return UNITY_END();
+}