diff --git a/test/test.c b/test/test.c
index 3850ba4..1acd1e3 100644
--- a/test/test.c
+++ b/test/test.c
@@ -3,8 +3,7 @@
 #include <assert.h>
 #include <stddef.h>
 
-#define JSONB_MAX_DEPTH 4
-#define JSONB_DEBUG
+#define JSONB_MAX_DEPTH 1028
 #include "json-build.h"
 
 #include "greatest.h"
@@ -16,33 +15,34 @@ check_valid_singles(void)
     jsonb b;
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_array(&b, buf, sizeof(buf)) >= 0);
-    ASSERT(jsonb_pop_array(&b, buf, sizeof(buf)) >= 0);
+    ASSERTm(buf, JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_END == jsonb_pop_array(&b, buf, sizeof(buf)));
     ASSERT_STR_EQ("[]", buf);
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_object(&b, buf, sizeof(buf)) >= 0);
-    ASSERT(jsonb_pop_object(&b, buf, sizeof(buf)) >= 0);
+    ASSERTm(buf, JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_END == jsonb_pop_object(&b, buf, sizeof(buf)));
     ASSERT_STR_EQ("{}", buf);
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_bool(&b, buf, sizeof(buf), 0) >= 0);
+    ASSERTm(buf, JSONB_END == jsonb_push_bool(&b, buf, sizeof(buf), 0));
     ASSERT_STR_EQ("false", buf);
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_bool(&b, buf, sizeof(buf), 1) >= 0);
+    ASSERTm(buf, JSONB_END == jsonb_push_bool(&b, buf, sizeof(buf), 1));
     ASSERT_STR_EQ("true", buf);
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_number(&b, buf, sizeof(buf), 10) >= 0);
+    ASSERTm(buf, JSONB_END == jsonb_push_number(&b, buf, sizeof(buf), 10));
     ASSERT_STR_EQ("10", buf);
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_string(&b, buf, sizeof(buf), "hi", 2) >= 0);
+    ASSERTm(buf,
+            JSONB_END == jsonb_push_string(&b, buf, sizeof(buf), "hi", 2));
     ASSERT_STR_EQ("\"hi\"", buf);
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_null(&b, buf, sizeof(buf)) >= 0);
+    ASSERTm(buf, JSONB_END == jsonb_push_null(&b, buf, sizeof(buf)));
     ASSERT_STR_EQ("null", buf);
 
     PASS();
@@ -55,16 +55,17 @@ check_valid_array(void)
     jsonb b;
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_array(&b, buf, sizeof(buf)) >= 0);
+    ASSERTm(buf, JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
     {
-        ASSERT(jsonb_push_bool(&b, buf, sizeof(buf), 1) >= 0);
-        ASSERT(jsonb_push_bool(&b, buf, sizeof(buf), 0) >= 0);
-        ASSERT(jsonb_push_null(&b, buf, sizeof(buf)) >= 0);
-        ASSERT(jsonb_push_number(&b, buf, sizeof(buf), 10) >= 0);
-        ASSERT(jsonb_push_string(&b, buf, sizeof(buf), "foo", 3) >= 0);
-        ASSERT(jsonb_push_object(&b, buf, sizeof(buf)) >= 0);
-        ASSERT(jsonb_pop_object(&b, buf, sizeof(buf)) >= 0);
-        ASSERT(jsonb_pop_array(&b, buf, sizeof(buf)) >= 0);
+        ASSERTm(buf, JSONB_OK == jsonb_push_bool(&b, buf, sizeof(buf), 1));
+        ASSERTm(buf, JSONB_OK == jsonb_push_bool(&b, buf, sizeof(buf), 0));
+        ASSERTm(buf, JSONB_OK == jsonb_push_null(&b, buf, sizeof(buf)));
+        ASSERTm(buf, JSONB_OK == jsonb_push_number(&b, buf, sizeof(buf), 10));
+        ASSERTm(buf,
+                JSONB_OK == jsonb_push_string(&b, buf, sizeof(buf), "foo", 3));
+        ASSERTm(buf, JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
+        ASSERTm(buf, JSONB_OK == jsonb_pop_object(&b, buf, sizeof(buf)));
+        ASSERTm(buf, JSONB_END == jsonb_pop_array(&b, buf, sizeof(buf)));
     }
 
     ASSERT_STR_EQ("[true,false,null,10,\"foo\",{}]", buf);
@@ -79,22 +80,23 @@ check_valid_object(void)
     jsonb b;
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_object(&b, buf, sizeof(buf)) >= 0);
+    ASSERTm(buf, JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
     {
-        ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "a", 1) >= 0);
-        ASSERT(jsonb_push_bool(&b, buf, sizeof(buf), 1) >= 0);
-        ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "b", 1) >= 0);
-        ASSERT(jsonb_push_bool(&b, buf, sizeof(buf), 0) >= 0);
-        ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "c", 1) >= 0);
-        ASSERT(jsonb_push_null(&b, buf, sizeof(buf)) >= 0);
-        ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "d", 1) >= 0);
-        ASSERT(jsonb_push_number(&b, buf, sizeof(buf), 10) >= 0);
-        ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "e", 1) >= 0);
-        ASSERT(jsonb_push_string(&b, buf, sizeof(buf), "foo", 3) >= 0);
-        ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "f", 1) >= 0);
-        ASSERT(jsonb_push_array(&b, buf, sizeof(buf)) >= 0);
-        ASSERT(jsonb_pop_array(&b, buf, sizeof(buf)) >= 0);
-        ASSERT(jsonb_pop_object(&b, buf, sizeof(buf)) >= 0);
+        ASSERTm(buf, JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "a", 1));
+        ASSERTm(buf, JSONB_OK == jsonb_push_bool(&b, buf, sizeof(buf), 1));
+        ASSERTm(buf, JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "b", 1));
+        ASSERTm(buf, JSONB_OK == jsonb_push_bool(&b, buf, sizeof(buf), 0));
+        ASSERTm(buf, JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "c", 1));
+        ASSERTm(buf, JSONB_OK == jsonb_push_null(&b, buf, sizeof(buf)));
+        ASSERTm(buf, JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "d", 1));
+        ASSERTm(buf, JSONB_OK == jsonb_push_number(&b, buf, sizeof(buf), 10));
+        ASSERTm(buf, JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "e", 1));
+        ASSERTm(buf,
+                JSONB_OK == jsonb_push_string(&b, buf, sizeof(buf), "foo", 3));
+        ASSERTm(buf, JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "f", 1));
+        ASSERTm(buf, JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
+        ASSERTm(buf, JSONB_OK == jsonb_pop_array(&b, buf, sizeof(buf)));
+        ASSERTm(buf, JSONB_END == jsonb_pop_object(&b, buf, sizeof(buf)));
     }
 
     ASSERT_STR_EQ(
@@ -114,60 +116,82 @@ SUITE(valid_output)
 TEST
 check_deep_nesting_array(void)
 {
-    char buf[2048];
+    char buf[JSONB_MAX_DEPTH * sizeof("[]")];
     jsonb b;
     int i;
 
     jsonb_init(&b);
     for (i = 0; i < JSONB_MAX_DEPTH; ++i)
-        ASSERT(jsonb_push_array(&b, buf, sizeof(buf)) >= 0);
-    for (i = 0; i < JSONB_MAX_DEPTH; ++i)
-        ASSERT(jsonb_pop_array(&b, buf, sizeof(buf)) >= 0);
+        ASSERTm(buf, JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
+    for (i = 0; i < JSONB_MAX_DEPTH - 1; ++i)
+        ASSERTm(buf, JSONB_OK == jsonb_pop_array(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_END == jsonb_pop_array(&b, buf, sizeof(buf)));
+
     PASS();
 }
 
 TEST
 check_deep_nesting_object(void)
 {
-    char buf[4096];
+    char buf[JSONB_MAX_DEPTH * (sizeof("{}") + sizeof("\"a\":"))];
     jsonb b;
     int i;
 
     jsonb_init(&b);
     for (i = 0; i < JSONB_MAX_DEPTH - 1; ++i) {
-        ASSERT(jsonb_push_object(&b, buf, sizeof(buf)) >= 0);
-        ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "a", 1) >= 0);
-    }
-    ASSERT(jsonb_push_object(&b, buf, sizeof(buf)) >= 0);
-    for (i = 0; i < JSONB_MAX_DEPTH; ++i) {
-        ASSERT(jsonb_pop_object(&b, buf, sizeof(buf)) >= 0);
+        ASSERTm(buf, JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
+        ASSERTm(buf, JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "a", 1));
     }
+    ASSERTm(buf, JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
+    for (i = 0; i < JSONB_MAX_DEPTH - 1; ++i)
+        ASSERTm(buf, JSONB_OK == jsonb_pop_object(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_END == jsonb_pop_object(&b, buf, sizeof(buf)));
+
     PASS();
 }
 
 TEST
 check_deep_nesting_object_and_array(void)
 {
-    char buf[8192];
+    char buf[JSONB_MAX_DEPTH * (sizeof("[{}]") + sizeof("\"a\":"))];
     jsonb b;
     int i;
 
     jsonb_init(&b);
     for (i = 0; i < JSONB_MAX_DEPTH; ++i) {
         if (i % 2 == 0) {
-            ASSERT(jsonb_push_object(&b, buf, sizeof(buf)) >= 0);
-            ASSERT(jsonb_push_key(&b, buf, sizeof(buf), "a", 1) >= 0);
+            ASSERTm(buf, JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
+            ASSERTm(buf,
+                    JSONB_OK == jsonb_push_key(&b, buf, sizeof(buf), "a", 1));
         }
         else {
-            ASSERT(jsonb_push_array(&b, buf, sizeof(buf)) >= 0);
+            ASSERTm(buf, JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
         }
     }
-    for (i = 0; i < JSONB_MAX_DEPTH; ++i) {
-        if (i % 2 == 0)
-            ASSERT(jsonb_pop_array(&b, buf, sizeof(buf)) >= 0);
-        else
-            ASSERT(jsonb_pop_object(&b, buf, sizeof(buf)) >= 0);
+
+    if (JSONB_MAX_DEPTH % 2 != 0) {
+        ASSERTm(buf, jsonb_push_null(&b, buf, sizeof(buf)) == JSONB_OK);
+        for (i = 0; i < JSONB_MAX_DEPTH - 1; ++i) {
+            if (i % 2 == 0)
+                ASSERTm(buf,
+                        JSONB_OK == jsonb_pop_object(&b, buf, sizeof(buf)));
+            else
+                ASSERTm(buf,
+                        JSONB_OK == jsonb_pop_array(&b, buf, sizeof(buf)));
+        }
+    }
+    else {
+        for (i = 0; i < JSONB_MAX_DEPTH - 1; ++i) {
+            if (i % 2 == 0)
+                ASSERTm(buf,
+                        JSONB_OK == jsonb_pop_array(&b, buf, sizeof(buf)));
+            else
+                ASSERTm(buf,
+                        JSONB_OK == jsonb_pop_object(&b, buf, sizeof(buf)));
+        }
     }
+    ASSERTm(buf, JSONB_END == jsonb_pop_object(&b, buf, sizeof(buf)));
+
     PASS();
 }
 
@@ -194,14 +218,15 @@ check_string_escaping(void)
     jsonb b;
 
     jsonb_init(&b);
-    ASSERT(jsonb_push_array(&b, buf, sizeof(buf)) >= 0);
+    ASSERTm(buf, JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
     for (i = 0; i < sizeof(strs) / sizeof(char *); ++i) {
         size_t len = strlen(strs[i]);
         size_t prev_pos = b.pos;
-        ASSERT(jsonb_push_string(&b, buf, sizeof(buf), strs[i], len) >= 0);
+        ASSERTm(buf,
+                jsonb_push_string(&b, buf, sizeof(buf), strs[i], len) >= 0);
         ASSERT_STR_EQ(expect[i], buf + prev_pos);
     }
-    ASSERT(jsonb_pop_array(&b, buf, sizeof(buf)) >= 0);
+    ASSERTm(buf, JSONB_END == jsonb_pop_array(&b, buf, sizeof(buf)));
 
     PASS();
 }
@@ -219,25 +244,28 @@ check_invalid_top_level_tokens_in_sequence(void)
 
     jsonb_init(&b);
     jsonb_push_bool(&b, buf, sizeof(buf), 1);
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_bool(&b, buf, sizeof(buf), 0));
+    ASSERTm(buf,
+            JSONB_ERROR_INPUT == jsonb_push_bool(&b, buf, sizeof(buf), 0));
 
     jsonb_init(&b);
     jsonb_push_array(&b, buf, sizeof(buf));
     jsonb_pop_array(&b, buf, sizeof(buf));
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_array(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_ERROR_INPUT == jsonb_push_array(&b, buf, sizeof(buf)));
 
     jsonb_init(&b);
     jsonb_push_array(&b, buf, sizeof(buf));
     jsonb_pop_array(&b, buf, sizeof(buf));
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_bool(&b, buf, sizeof(buf), 1));
+    ASSERTm(buf,
+            JSONB_ERROR_INPUT == jsonb_push_bool(&b, buf, sizeof(buf), 1));
 
     jsonb_init(&b);
     jsonb_push_bool(&b, buf, sizeof(buf), 1);
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_array(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_ERROR_INPUT == jsonb_push_array(&b, buf, sizeof(buf)));
 
     jsonb_init(&b);
     jsonb_push_bool(&b, buf, sizeof(buf), 1);
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_string(&b, buf, sizeof(buf), "", 0));
+    ASSERTm(buf, JSONB_ERROR_INPUT
+                     == jsonb_push_string(&b, buf, sizeof(buf), "", 0));
 
     PASS();
 }
@@ -249,8 +277,8 @@ check_not_enough_buffer_memory(void)
     jsonb b;
 
     jsonb_init(&b);
-    ASSERT(JSONB_ERROR_NOMEM == jsonb_push_bool(&b, buf, 0, 1));
-    ASSERT(JSONB_END == jsonb_push_bool(&b, buf, sizeof(buf), 1));
+    ASSERTm(buf, JSONB_ERROR_NOMEM == jsonb_push_bool(&b, buf, 0, 1));
+    ASSERTm(buf, JSONB_END == jsonb_push_bool(&b, buf, sizeof(buf), 1));
 
     PASS();
 }
@@ -258,37 +286,54 @@ check_not_enough_buffer_memory(void)
 TEST
 check_out_of_bounds_access(void)
 {
-    char buf[1024];
+    char buf[JSONB_MAX_DEPTH * sizeof("[")];
     jsonb b;
 
     jsonb_init(&b);
     while (1) {
-        if (JSONB_ERROR_STACK == jsonb_push_array(&b, buf, sizeof(buf)))
-            break;
+        if (JSONB_ERROR_STACK == jsonb_push_array(&b, buf, sizeof(buf))) break;
     }
 
     PASS();
 }
 
 TEST
-check_no_operation_after_done(void)
+check_single_no_operation_after_done(void)
 {
     char buf[1024];
     jsonb b;
 
     jsonb_init(&b);
-    ASSERT(JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
-    ASSERT(JSONB_END == jsonb_pop_array(&b, buf, sizeof(buf)));
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_array(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_END == jsonb_push_null(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_ERROR_INPUT == jsonb_push_null(&b, buf, sizeof(buf)));
+
+    PASS();
+}
+
+TEST
+check_array_no_operation_after_done(void)
+{
+    char buf[1024];
+    jsonb b;
 
     jsonb_init(&b);
-    ASSERT(JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
-    ASSERT(JSONB_END == jsonb_pop_object(&b, buf, sizeof(buf)));
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_object(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_OK == jsonb_push_array(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_END == jsonb_pop_array(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_ERROR_INPUT == jsonb_push_array(&b, buf, sizeof(buf)));
+
+    PASS();
+}
+
+TEST
+check_object_no_operation_after_done(void)
+{
+    char buf[1024];
+    jsonb b;
 
     jsonb_init(&b);
-    ASSERT(JSONB_END == jsonb_push_null(&b, buf, sizeof(buf)));
-    ASSERT(JSONB_ERROR_INPUT == jsonb_push_null(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_OK == jsonb_push_object(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_END == jsonb_pop_object(&b, buf, sizeof(buf)));
+    ASSERTm(buf, JSONB_ERROR_INPUT == jsonb_push_object(&b, buf, sizeof(buf)));
 
     PASS();
 }
@@ -298,7 +343,9 @@ SUITE(force_error)
     RUN_TEST(check_invalid_top_level_tokens_in_sequence);
     RUN_TEST(check_not_enough_buffer_memory);
     RUN_TEST(check_out_of_bounds_access);
-    RUN_TEST(check_no_operation_after_done);
+    RUN_TEST(check_single_no_operation_after_done);
+    RUN_TEST(check_array_no_operation_after_done);
+    RUN_TEST(check_object_no_operation_after_done);
 }
 
 GREATEST_MAIN_DEFS();