diff --git a/src/test/testprefs.c b/src/test/testprefs.c
index 19263486..3ba5861f 100644
--- a/src/test/testprefs.c
+++ b/src/test/testprefs.c
@@ -90,23 +90,29 @@ TEST test_json_map_0(JSON_ref parsedData) {
     long lVal;
     float fVal;
     char *val;
+    bool ok = false;
 
-    json_mapParseLongValue(parsedData, "intKey2", &lVal, 10);
+    ok = json_mapParseLongValue(parsedData, "intKey2", &lVal, 10);
+    ASSERT(ok);
     ASSERT(lVal == 0);
 
-    json_mapCopyStringValue(parsedData, "key0", &val);
+    ok = json_mapCopyStringValue(parsedData, "key0", &val);
+    ASSERT(ok);
     ASSERT(strcmp(val, "a value zero") == 0);
     FREE(val);
 
-    json_mapCopyStringValue(parsedData, "key1", &val);
+    ok = json_mapCopyStringValue(parsedData, "key1", &val);
+    ASSERT(ok);
     ASSERT(strcmp(val, "  \t ") == 0);
     FREE(val);
 
-    json_mapCopyStringValue(parsedData, "key2", &val);
+    ok = json_mapCopyStringValue(parsedData, "key2", &val);
+    ASSERT(ok);
     ASSERT(strcmp(val, "{    \t \n}") == 0);
     FREE(val);
 
-    json_mapCopyStringValue(parsedData, "key3", &val);
+    ok = json_mapCopyStringValue(parsedData, "key3", &val);
+    ASSERT(ok);
     ASSERT(strcmp(val, "{   \t \n  \"subkey0\" : \"subval0\",   \"subkey1\" : { \"moar\" : \"recursion\" }  ,   \"subkey2\" : \"line0      \n   \tline1      \tline2\"  \n}") == 0);
     do {
         JSON_ref parsedSubData = NULL;
@@ -114,15 +120,18 @@ TEST test_json_map_0(JSON_ref parsedData) {
         ASSERT(tokSubCount > 0);
 
         char *subval;
-        json_mapCopyStringValue(parsedSubData, "subkey0", &subval);
+        ok = json_mapCopyStringValue(parsedSubData, "subkey0", &subval);
+        ASSERT(ok);
         ASSERT(strcmp(subval, "subval0") == 0);
         FREE(subval);
 
-        json_mapCopyStringValue(parsedSubData, "subkey1", &subval);
+        ok = json_mapCopyStringValue(parsedSubData, "subkey1", &subval);
+        ASSERT(ok);
         ASSERT(strcmp(subval, "{ \"moar\" : \"recursion\" }") == 0);
         FREE(subval);
 
-        json_mapCopyStringValue(parsedSubData, "subkey2", &subval);
+        ok = json_mapCopyStringValue(parsedSubData, "subkey2", &subval);
+        ASSERT(ok);
         ASSERT(strcmp(subval, "line0      \n   \tline1      \tline2") == 0);
         FREE(subval);
 
@@ -130,40 +139,110 @@ TEST test_json_map_0(JSON_ref parsedData) {
     } while (0);
     FREE(val);
 
-    json_mapCopyStringValue(parsedData, "key4", &val);
+    ok = json_mapCopyStringValue(parsedData, "key4", &val);
+    ASSERT(ok);
     ASSERT(strcmp(val, "[ \"Q\",    \"W\",  \"E\",            \"R\",  \"T\",  \"Y\",  \"U\",   \"I\",           \"O\",   \"P\", { \"x\" : [ 22, 4, \"ab\" ] } ]") == 0);
-    // TODO : subarray checks
     FREE(val);
 
-    json_mapCopyStringValue(parsedData, "key5", &val);
+    JSON_ref array = NULL;
+    int errCount = json_mapCopyJSON(parsedData, "key4", &array);
+    ASSERT(errCount > 0);
+    ASSERT(array);
+    ASSERT(!json_isMap(array));
+    ASSERT(json_isArray(array));
+    ASSERT(json_isMap(parsedData));
+    ASSERT(!json_isArray(parsedData));
+
+    ok = json_arrayCount(array, &lVal);
+    ASSERT(lVal == 11);
+
+    ok = json_arrayCopyStringValueAtIndex(array, 3, &val);
+    ASSERT(ok);
+    ASSERT(strcmp(val, "R") == 0);
+    FREE(val);
+
+    do {
+        JSON_ref submap = NULL;
+
+        errCount = json_arrayCopyJSONAtIndex(array, 42, &submap);
+        ASSERT(errCount < 0);
+        ASSERT(!submap);
+
+        errCount = json_arrayCopyJSONAtIndex(array, -1, &submap);
+        ASSERT(errCount < 0);
+        ASSERT(!submap);
+
+        errCount = json_arrayCopyJSONAtIndex(array, 10, &submap);
+        ASSERT(errCount > 0);
+        ASSERT(submap);
+        ASSERT(json_isMap(submap));
+
+        do {
+            JSON_ref subary = NULL;
+            errCount = json_mapCopyJSON(submap, "x", &subary);
+            ASSERT(errCount > 1);
+            ASSERT(subary);
+            ASSERT(json_isArray(subary));
+
+            ok = json_arrayCount(subary, &lVal);
+            ASSERT(ok);
+            ASSERT(lVal == 3);
+
+            ok = json_arrayParseLongValueAtIndex(subary, 0, &lVal, /*base:*/10);
+            ASSERT(ok);
+            ASSERT(lVal == 22);
+
+            ok = json_arrayParseFloatValueAtIndex(subary, 1, &fVal);
+            ASSERT(ok);
+            ASSERT(fVal == 4.f);
+
+            json_destroy(&subary);
+        } while (0);
+
+        json_destroy(&submap);
+    } while (0);
+
+    json_destroy(&array);
+
+    ok = json_mapCopyStringValue(parsedData, "key5", &val);
+    ASSERT(ok);
     ASSERT(strcmp(val, "") == 0);
     FREE(val);
 
-    json_mapParseLongValue(parsedData, "intKey0", &lVal, 10);
+    ok = json_mapParseLongValue(parsedData, "intKey0", &lVal, 10);
+    ASSERT(ok);
     ASSERT(lVal == 42);
 
-    json_mapParseLongValue(parsedData, "intKey1", &lVal, 10);
+    ok = json_mapParseLongValue(parsedData, "intKey1", &lVal, 10);
+    ASSERT(ok);
     ASSERT(lVal == -101);
 
-    json_mapParseLongValue(parsedData, "intKey3", &lVal, 16);
+    ok = json_mapParseLongValue(parsedData, "intKey3", &lVal, 16);
+    ASSERT(ok);
     ASSERT(lVal == 0x2400);
 
-    json_mapParseLongValue(parsedData, "intKey4", &lVal, 2);
+    ok = json_mapParseLongValue(parsedData, "intKey4", &lVal, 2);
+    ASSERT(ok);
     ASSERT(lVal == 191);
 
-    json_mapParseLongValue(parsedData, "intKey4", &lVal, 10);
+    ok = json_mapParseLongValue(parsedData, "intKey4", &lVal, 10);
+    ASSERT(ok);
     ASSERT(lVal == 10111111);
 
-    json_mapParseFloatValue(parsedData, "floatKey0", &fVal);
+    ok = json_mapParseFloatValue(parsedData, "floatKey0", &fVal);
+    ASSERT(ok);
     ASSERT(fVal == 0.f);
 
-    json_mapParseFloatValue(parsedData, "floatKey1", &fVal);
+    ok = json_mapParseFloatValue(parsedData, "floatKey1", &fVal);
+    ASSERT(ok);
     ASSERT(fVal == -.0001220703125);
 
-    json_mapParseFloatValue(parsedData, "floatKey2", &fVal);
+    ok = json_mapParseFloatValue(parsedData, "floatKey2", &fVal);
+    ASSERT(ok);
     ASSERT((long)(fVal*10000000) == 31415928);
 
-    json_mapParseFloatValue(parsedData, "floatKey3", &fVal);
+    ok = json_mapParseFloatValue(parsedData, "floatKey3", &fVal);
+    ASSERT(ok);
     ASSERT((long)fVal == -310);
 
     PASS();
@@ -212,68 +291,101 @@ TEST test_json_serialization() {
 
 TEST test_json_serialization_pretty() {
 
+    bool ok = false;
+
     const char *testMapStr0 = get_sample_json_0();
 
     JSON_ref parsedData = NULL;
     int tokCount = json_createFromString(testMapStr0, &parsedData);
     ASSERT(tokCount > 0);
+    ASSERT(parsedData);
 
     char *str = STRDUP("/tmp/json-pretty-XXXXXX");
     int fd = mkstemp(str);
     ASSERT(fd > 0);
     FREE(str);
 
-    json_serialize(parsedData, fd, /*pretty:*/true);
+    ok = json_serialize(parsedData, fd, /*pretty:*/true);
+    ASSERT(ok);
     json_destroy(&parsedData);
+    ASSERT(!parsedData);
+
     lseek(fd, 0, SEEK_SET);
     tokCount = json_createFromFD(fd, &parsedData);
     ASSERT(tokCount > 0);
+    ASSERT(parsedData);
+
+    close(fd);
 
     do {
-        long lVal;
-        float fVal;
-        char *val;
+        long lVal = 42;
+        float fVal = -1.f;
+        char *val = (char *)0xdeadc0de;
 
-        json_mapParseLongValue(parsedData, "intKey2", &lVal, 10);
+        ok = json_mapParseLongValue(parsedData, "nonexistentKey0", &lVal, 10);
+        ASSERT(!ok);
+        ASSERT(lVal == 42);
+
+        ok = json_mapParseFloatValue(parsedData, "nonexistentKey1", &fVal);
+        ASSERT(!ok);
+        ASSERT(fVal == -1.f);
+
+        ok = json_mapCopyStringValue(parsedData, "nonexistentKey2", &val);
+        ASSERT(!ok);
+        ASSERT(val == (char *)0xdeadc0de);
+
+        ok = json_mapParseLongValue(parsedData, "intKey2", &lVal, 10);
+        ASSERT(ok);
         ASSERT(lVal == 0);
 
-        json_mapCopyStringValue(parsedData, "key0", &val);
+        ok = json_mapCopyStringValue(parsedData, "key0", &val);
+        ASSERT(ok);
         ASSERT(strcmp(val, "a value zero") == 0);
         FREE(val);
 
-        json_mapCopyStringValue(parsedData, "key1", &val);
+        ok = json_mapCopyStringValue(parsedData, "key1", &val);
+        ASSERT(ok);
         ASSERT(strcmp(val, "  \t ") == 0);
         FREE(val);
 
-        json_mapCopyStringValue(parsedData, "key2", &val);
+        ok = json_mapCopyStringValue(parsedData, "key2", &val);
+        ASSERT(ok);
         do {
             JSON_ref parsedSubData = NULL;
             int tokSubCount = json_createFromString(val, &parsedSubData);
             ASSERT(tokSubCount == 1);
+            ASSERT(parsedSubData);
             ASSERT(((JSON_s *)parsedSubData)->jsonTokens[0].type == JSMN_OBJECT);
+            ASSERT(json_isMap(parsedSubData));
             json_destroy(&parsedSubData);
         } while (0);
         FREE(val);
 
-        json_mapCopyStringValue(parsedData, "key3", &val);
+        ok = json_mapCopyStringValue(parsedData, "key3", &val);
+        ASSERT(ok);
         do {
             JSON_ref parsedSubData = NULL;
             int tokSubCount = json_createFromString(val, &parsedSubData);
             ASSERT(tokSubCount == 9);
+            ASSERT(parsedSubData);
 
-            char *subval;
-            json_mapCopyStringValue(parsedSubData, "subkey0", &subval);
+            char *subval = NULL;
+            ok = json_mapCopyStringValue(parsedSubData, "subkey0", &subval);
+            ASSERT(ok);
             ASSERT(strcmp(subval, "subval0") == 0);
             FREE(subval);
 
-            json_mapCopyStringValue(parsedSubData, "subkey1", &subval);
+            ok = json_mapCopyStringValue(parsedSubData, "subkey1", &subval);
+            ASSERT(ok);
             do {
                 JSON_ref parsedSubSubData = NULL;
                 int tokSubSubCount = json_createFromString(subval, &parsedSubSubData);
                 ASSERT(tokSubSubCount == 3);
+                ASSERT(parsedSubSubData);
 
                 char *subsubval;
-                json_mapCopyStringValue(parsedSubSubData, "moar", &subsubval);
+                ok = json_mapCopyStringValue(parsedSubSubData, "moar", &subsubval);
+                ASSERT(ok);
                 ASSERT(strcmp(subsubval, "recursion") == 0);
                 FREE(subsubval);
 
@@ -281,7 +393,8 @@ TEST test_json_serialization_pretty() {
             } while (0);
             FREE(subval);
 
-            json_mapCopyStringValue(parsedSubData, "subkey2", &subval);
+            ok = json_mapCopyStringValue(parsedSubData, "subkey2", &subval);
+            ASSERT(ok);
             ASSERT(strcmp(subval, "line0      \n   \tline1      \tline2") == 0);
             FREE(subval);
 
@@ -289,45 +402,59 @@ TEST test_json_serialization_pretty() {
         } while (0);
         FREE(val);
 
-        json_mapCopyStringValue(parsedData, "key4", &val);
+        ok = json_mapCopyStringValue(parsedData, "key4", &val);
+        ASSERT(ok);
         do {
             JSON_ref parsedSubData = NULL;
             int tokSubCount = json_createFromString(val, &parsedSubData);
             ASSERT(tokSubCount == 17);
-            // TODO : subarray checks
+            ASSERT(parsedSubData);
+            ASSERT(json_isArray(parsedSubData));
+            ok = json_arrayCount(parsedSubData, &lVal);
+            ASSERT(ok);
+            ASSERT(lVal == 11);
             json_destroy(&parsedSubData);
         } while (0);
         FREE(val);
 
-        json_mapCopyStringValue(parsedData, "key5", &val);
+        ok = json_mapCopyStringValue(parsedData, "key5", &val);
         ASSERT(strcmp(val, "") == 0);
         FREE(val);
 
-        json_mapParseLongValue(parsedData, "intKey0", &lVal, 10);
+        ok = json_mapParseLongValue(parsedData, "intKey0", &lVal, 10);
+        ASSERT(ok);
         ASSERT(lVal == 42);
 
-        json_mapParseLongValue(parsedData, "intKey1", &lVal, 10);
+        ok = json_mapParseLongValue(parsedData, "intKey1", &lVal, 10);
+        ASSERT(ok);
         ASSERT(lVal == -101);
 
-        json_mapParseLongValue(parsedData, "intKey3", &lVal, 16);
+        ok = json_mapParseLongValue(parsedData, "intKey3", &lVal, 16);
+        ASSERT(ok);
         ASSERT(lVal == 0x2400);
 
-        json_mapParseLongValue(parsedData, "intKey4", &lVal, 2);
+        ok = json_mapParseLongValue(parsedData, "intKey4", &lVal, 2);
+        ASSERT(ok);
         ASSERT(lVal == 191);
 
-        json_mapParseLongValue(parsedData, "intKey4", &lVal, 10);
+        ok = json_mapParseLongValue(parsedData, "intKey4", &lVal, 10);
+        ASSERT(ok);
         ASSERT(lVal == 10111111);
 
-        json_mapParseFloatValue(parsedData, "floatKey0", &fVal);
+        ok = json_mapParseFloatValue(parsedData, "floatKey0", &fVal);
+        ASSERT(ok);
         ASSERT(fVal == 0.f);
 
-        json_mapParseFloatValue(parsedData, "floatKey1", &fVal);
+        ok = json_mapParseFloatValue(parsedData, "floatKey1", &fVal);
+        ASSERT(ok);
         ASSERT(fVal == -.0001220703125);
 
-        json_mapParseFloatValue(parsedData, "floatKey2", &fVal);
+        ok = json_mapParseFloatValue(parsedData, "floatKey2", &fVal);
+        ASSERT(ok);
         ASSERT((long)(fVal*10000000) == 31415928);
 
-        json_mapParseFloatValue(parsedData, "floatKey3", &fVal);
+        ok = json_mapParseFloatValue(parsedData, "floatKey3", &fVal);
+        ASSERT(ok);
         ASSERT((long)fVal == -310);
     } while (0);
 
@@ -337,6 +464,240 @@ TEST test_json_serialization_pretty() {
     PASS();
 }
 
+TEST test_json_resilient_api() {
+    JSON_ref map = NULL;
+    JSON_ref array = NULL;
+
+    bool ok = true;
+    bool bVal = false;
+    long lVal = 0;
+    float fVal = 0.f;
+    char *val = NULL;
+    JSON_ref jsonRef = NULL;
+
+    int errCount = json_createFromString("{ \"aKey\" : \"42\", \"aKey2\" : true }", &map);
+    ASSERT(errCount == 5);
+    ASSERT(map);
+    ASSERT(json_isMap(map));
+
+    errCount = json_createFromString("[ \"item0\", \"item1\" ]", &array);
+    ASSERT(errCount == 3);
+    ASSERT(array);
+    ASSERT(json_isArray(array));
+
+    // ...
+
+    ASSERT(!json_isMap((JSON_ref)NULL));
+    ASSERT(!json_isArray((JSON_ref)NULL));
+
+    // ...
+
+    errCount = json_mapCopyJSON((JSON_ref)NULL, "aKey", &jsonRef);
+    ASSERT(errCount < 0);
+    ASSERT(!jsonRef);
+
+    errCount = json_mapCopyJSON(map, NULL, &jsonRef);
+    ASSERT(errCount < 0);
+    ASSERT(!jsonRef);
+
+    errCount = json_mapCopyJSON(map, "aKey", (JSON_ref *)NULL);
+    ASSERT(errCount < 0);
+
+    // ...
+
+    ok = json_mapCopyStringValue((JSON_ref)NULL, "aKey", &val);
+    ASSERT(!ok);
+    ASSERT(!val);
+
+    ok = json_mapCopyStringValue(map, NULL, &val);
+    ASSERT(!ok);
+    ASSERT(!val);
+
+    ok = json_mapCopyStringValue(map, "aKey", (char **)NULL);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapParseLongValue((JSON_ref)NULL, "aKey", &lVal, /*base:*/10);
+    ASSERT(!ok);
+    ASSERT(lVal == 0);
+
+    ok = json_mapParseLongValue(map, NULL, &lVal, /*base:*/10);
+    ASSERT(!ok);
+    ASSERT(lVal == 0);
+
+    ok = json_mapParseLongValue(map, "aKey", (long *)NULL, /*base:*/10);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapParseFloatValue((JSON_ref)NULL, "aKey", &fVal);
+    ASSERT(!ok);
+    ASSERT(fVal == 0.f);
+
+    ok = json_mapParseFloatValue(map, NULL, &fVal);
+    ASSERT(!ok);
+    ASSERT(fVal == 0.f);
+
+    ok = json_mapParseFloatValue(map, "aKey", (float *)NULL);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapParseBoolValue((JSON_ref)NULL, "aKey2", &bVal);
+    ASSERT(!ok);
+    ASSERT(bVal == 0.f);
+
+    ok = json_mapParseBoolValue(map, NULL, &bVal);
+    ASSERT(!ok);
+    ASSERT(bVal == 0.f);
+
+    ok = json_mapParseBoolValue(map, "aKey2", (bool *)NULL);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapSetStringValue((JSON_ref)NULL, "aKey", "aVal");
+    ASSERT(!ok);
+
+    ok = json_mapSetStringValue(map, NULL, "aVal");
+    ASSERT(!ok);
+
+    ok = json_mapSetStringValue((JSON_ref)map, "aKey", NULL);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapSetRawStringValue((JSON_ref)NULL, "aKey", "\"aVal\"");
+    ASSERT(!ok);
+
+    ok = json_mapSetRawStringValue(map, NULL, "\"aVal\"");
+    ASSERT(!ok);
+
+    ok = json_mapSetRawStringValue((JSON_ref)map, "aKey", NULL);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapSetJSONValue((JSON_ref)NULL, "aKey", array);
+    ASSERT(!ok);
+
+    ok = json_mapSetJSONValue(map, NULL, array);
+    ASSERT(!ok);
+
+    ok = json_mapSetJSONValue((JSON_ref)map, "aKey", NULL);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapSetLongValue((JSON_ref)NULL, "aKey", 22);
+    ASSERT(!ok);
+
+    ok = json_mapSetLongValue(map, NULL, 22);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapSetBoolValue((JSON_ref)NULL, "aKey", true);
+    ASSERT(!ok);
+
+    ok = json_mapSetBoolValue(map, NULL, true);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapSetFloatValue((JSON_ref)NULL, "aKey", -1.25);
+    ASSERT(!ok);
+
+    ok = json_mapSetFloatValue(map, NULL, -1.25);
+    ASSERT(!ok);
+
+    // ...
+
+    ok = json_mapParseLongValue(map, "aKey", &lVal, /*base:*/10);
+    ASSERT(ok);
+    ASSERT(lVal == 42);
+
+    ok = json_mapParseBoolValue(map, "aKey2", &bVal);
+    ASSERT(ok);
+    ASSERT(bVal == true);
+
+    // ...
+
+    errCount = json_arrayCopyJSONAtIndex((JSON_ref)NULL, 0, &jsonRef);
+    ASSERT(errCount < 0);
+    ASSERT(!jsonRef);
+
+    errCount = json_arrayCopyJSONAtIndex(array, 100, &jsonRef);
+    ASSERT(errCount < 0);
+    ASSERT(!jsonRef);
+
+    errCount = json_arrayCopyJSONAtIndex(array, 0, (JSON_ref *)NULL);
+    ASSERT(errCount < 0);
+
+    // ...
+
+    ok = json_arrayCopyStringValueAtIndex((JSON_ref)NULL, 0, &val);
+    ASSERT(!ok);
+    ASSERT(!val);
+
+    ok = json_arrayCopyStringValueAtIndex(array, 100, &val);
+    ASSERT(!ok);
+    ASSERT(!val);
+
+    ok = json_arrayCopyStringValueAtIndex(array, 0, (char **)NULL);
+    ASSERT(!ok);
+
+    // ...
+    lVal = 0;
+
+    ok = json_arrayParseLongValueAtIndex((JSON_ref)NULL, 0, &lVal, /*base:*/10);
+    ASSERT(!ok);
+    ASSERT(lVal == 0);
+
+    ok = json_arrayParseLongValueAtIndex(array, 100, &lVal, /*base:*/10);
+    ASSERT(!ok);
+    ASSERT(lVal == 0);
+
+    ok = json_arrayParseLongValueAtIndex(array, 0, (long *)NULL, /*base:*/10);
+    ASSERT(!ok);
+
+    // ...
+    fVal = 0.0;
+
+    ok = json_arrayParseFloatValueAtIndex((JSON_ref)NULL, 0, &fVal);
+    ASSERT(!ok);
+    ASSERT(fVal == 0.f);
+
+    ok = json_arrayParseFloatValueAtIndex(array, 100, &fVal);
+    ASSERT(!ok);
+    ASSERT(fVal == 0.f);
+
+    ok = json_arrayParseFloatValueAtIndex(array, 0, (float *)NULL);
+    ASSERT(!ok);
+
+    // ...
+    bVal = false;
+
+    ok = json_arrayParseBoolValueAtIndex((JSON_ref)NULL, 0, &bVal);
+    ASSERT(!ok);
+    ASSERT(bVal == 0.f);
+
+    ok = json_arrayParseBoolValueAtIndex(array, 100, &bVal);
+    ASSERT(!ok);
+    ASSERT(bVal == 0.f);
+
+    ok = json_arrayParseBoolValueAtIndex(array, 0, (bool *)NULL);
+    ASSERT(!ok);
+
+    // ...
+
+    json_destroy(&array);
+    json_destroy(&map);
+
+    PASS();
+}
+
 TEST test_json_raw_bool() {
 
     JSON_ref parsedData = NULL;
@@ -1241,8 +1602,8 @@ TEST test_json_map_mutation_1() {
     do {
         JSON_ref parsedSubData = NULL;
 
-        ok = json_mapCopyJSON(parsedData, "key2", &parsedSubData);
-        ASSERT(ok);
+        int errCount = json_mapCopyJSON(parsedData, "key2", &parsedSubData);
+        ASSERT(errCount > 0);
         ASSERT(parsedSubData);
 
         ok = json_mapCopyStringValue(parsedSubData, "foo", &val);
@@ -1256,8 +1617,8 @@ TEST test_json_map_mutation_1() {
         FREE(val);
         do {
             JSON_ref parsedSubSubData = NULL;
-            ok = json_mapCopyJSON(parsedSubData, "subKey0", &parsedSubSubData);
-            ASSERT(ok);
+            errCount = json_mapCopyJSON(parsedSubData, "subKey0", &parsedSubSubData);
+            ASSERT(errCount > 0);
             ASSERT(parsedSubSubData);
 
             ok = json_mapCopyStringValue(parsedSubSubData, "subFoo", &val);
@@ -1292,6 +1653,82 @@ TEST test_json_map_mutation_1() {
     PASS();
 }
 
+TEST test_json_array() {
+
+    long lVal = 0;
+    float fVal = 0.f;
+    bool bVal = false;
+    char *val = NULL;
+
+    JSON_ref array = NULL;
+    int errCount = json_createFromString("[ [ \"bar\" ], \"foo\", -21, 123.125e2, true, { \"aKey\" : \"aVal\" } ]", &array);
+    ASSERT(errCount == 10);
+    ASSERT(array);
+    ASSERT(json_isArray(array));
+    bool ok = json_arrayCount(array, &lVal);
+    ASSERT(ok);
+    ASSERT(lVal == 6);
+
+    int index = 0;
+
+    do {
+        JSON_ref subary = NULL;
+        errCount = json_arrayCopyJSONAtIndex(array, index++, &subary);
+        ASSERT(errCount == 2);
+        ASSERT(subary);
+        ASSERT(json_isArray(subary));
+
+        ok = json_arrayCopyStringValueAtIndex(subary, 0, &val);
+        ASSERT(ok);
+        ASSERT(strcmp(val, "bar") == 0);
+        FREE(val);
+
+        json_destroy(&subary);
+    } while (0);
+
+    ok = json_arrayCopyStringValueAtIndex(array, index++, &val);
+    ASSERT(ok);
+    ASSERT(strcmp(val, "foo") == 0);
+    FREE(val);
+
+    ok = json_arrayParseLongValueAtIndex(array, index++, &lVal, /*base:*/10);
+    ASSERT(ok);
+    ASSERT(lVal == -21);
+
+    ok = json_arrayParseFloatValueAtIndex(array, index++, &fVal);
+    ASSERT(ok);
+    ASSERT(fVal == 12312.5);
+
+    ok = json_arrayParseBoolValueAtIndex(array, index++, &bVal);
+    ASSERT(ok);
+    ASSERT(bVal == true);
+
+    do {
+        JSON_ref submap = NULL;
+        errCount = json_arrayCopyJSONAtIndex(array, index++, &submap);
+        ASSERT(errCount == 3);
+        ASSERT(submap);
+        ASSERT(json_isMap(submap));
+
+        ok = json_mapCopyStringValue(submap, "aKey", &val);
+        ASSERT(ok);
+        ASSERT(val);
+        ASSERT(strcmp(val, "aVal") == 0);
+        FREE(val);
+
+        json_destroy(&submap);
+    } while (0);
+
+    ok = json_arrayCopyStringValueAtIndex(array, index++, &val);
+    ASSERT(!ok);
+    ASSERT(!val);
+    FREE(val);
+
+    json_destroy(&array);
+
+    PASS();
+}
+
 TEST test_prefs_loadString_1() {
     const char *prefsJSON = get_default_preferences();
     prefs_loadString(prefsJSON);
@@ -1486,6 +1923,8 @@ GREATEST_SUITE(test_suite_prefs) {
     RUN_TESTp(test_json_serialization);
     RUN_TESTp(test_json_serialization_pretty);
 
+    RUN_TESTp(test_json_resilient_api);
+
     RUN_TESTp(test_json_raw_bool);
     RUN_TESTp(test_json_invalid_raw_bool);
     RUN_TESTp(test_json_raw_null);
@@ -1517,6 +1956,7 @@ GREATEST_SUITE(test_suite_prefs) {
     RUN_TESTp(test_json_map_invalid_arrayKey);
 
     RUN_TESTp(test_json_map_mutation_1);
+    RUN_TESTp(test_json_array);
 
     RUN_TESTp(test_prefs_loadString_1);
     RUN_TESTp(test_prefs_set_props);