Merging upstream version 2.1.148.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

9 files changed, 491 insertions, 334 deletions

diff --git a/tests/utests/basic/test_common.c b/tests/utests/basic/test_common.c
index 75235a2..46b80ab 100644
--- a/tests/utests/basic/test_common.c
+++ b/tests/utests/basic/test_common.c
@@ -1,4 +1,4 @@
-/*
+/**
  * @file test_common.c
  * @author: Radek Krejci <rkrejci@cesnet.cz>
  * @brief unit tests for functions from common.c
diff --git a/tests/utests/basic/test_context.c b/tests/utests/basic/test_context.c
index 4c4cc3f..cfba1d3 100644
--- a/tests/utests/basic/test_context.c
+++ b/tests/utests/basic/test_context.c
@@ -1,4 +1,4 @@
-/*
+/**
  * @file test_context.c
  * @author: Radek Krejci <rkrejci@cesnet.cz>
  * @brief unit tests for functions from context.c
@@ -298,8 +298,8 @@ test_models(void **state)
     assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1));
     lys_unres_glob_erase(&unres);
     ly_in_free(in, 0);
-    CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL,
-            "Name collision between module and submodule of name \"y\".", "Line number 1.");
+    CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL);
+    CHECK_LOG_CTX("Name collision between module and submodule of name \"y\".", "Line number 1.");
 
     assert_int_equal(LY_SUCCESS, ly_in_new_memory("module a {namespace urn:a;prefix a;include y;revision 2018-10-30; }", &in));
     assert_int_equal(LY_SUCCESS, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1));
@@ -308,8 +308,8 @@ test_models(void **state)
     assert_int_equal(LY_EVALID, lys_parse_in(UTEST_LYCTX, in, LYS_IN_YANG, NULL, NULL, &unres.creating, &mod1));
     lys_unres_glob_erase(&unres);
     ly_in_free(in, 0);
-    CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL,
-            "Name collision between module and submodule of name \"y\".", "Line number 1.");
+    CHECK_LOG_CTX("Parsing module \"y\" failed.", NULL);
+    CHECK_LOG_CTX("Name collision between module and submodule of name \"y\".", "Line number 1.");
 
     ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "submodule y {belongs-to b {prefix b;}}");
     assert_int_equal(LY_SUCCESS, ly_in_new_memory("module b {namespace urn:b;prefix b;include y;}", &in));
@@ -317,10 +317,10 @@ test_models(void **state)
     lys_unres_glob_revert(UTEST_LYCTX, &unres);
     lys_unres_glob_erase(&unres);
     ly_in_free(in, 0);
-    CHECK_LOG_CTX("Parsing module \"b\" failed.", NULL,
-            "Including \"y\" submodule into \"b\" failed.", NULL,
-            "Parsing submodule failed.", NULL,
-            "Name collision between submodules of name \"y\".", "Line number 1.");
+    CHECK_LOG_CTX("Parsing module \"b\" failed.", NULL);
+    CHECK_LOG_CTX("Including \"y\" submodule into \"b\" failed.", NULL);
+    CHECK_LOG_CTX("Parsing submodule failed.", NULL);
+    CHECK_LOG_CTX("Name collision between submodules of name \"y\".", "Line number 1.");
 
     /* selecting correct revision of the submodules */
     ly_ctx_reset_latests(UTEST_LYCTX);
@@ -338,19 +338,6 @@ test_models(void **state)
     assert_non_null(mod1->compiled);
     assert_non_null(mod1->parsed);
 
-#if 0
-    /* TODO in case we are able to remove the parsed schema, here we will test how it will handle missing import parsed schema */
-
-    assert_int_equal(LY_SUCCESS, ly_in_new_memory("module z {namespace urn:z;prefix z;import w {prefix w;revision-date 2018-10-24;}}", &in));
-    /* mod1->parsed is necessary to compile mod2 because of possible groupings, typedefs, ... */
-    ly_ctx_set_module_imp_clb(UTEST_LYCTX, NULL, NULL);
-    assert_int_equal(LY_ENOTFOUND, lys_create_module(UTEST_LYCTX, in, LYS_IN_YANG, 1, NULL, NULL, &mod2));
-    /*logbuf_assert("Unable to reload \"w\" module to import it into \"z\", source data not found.");*/
-    CHECK_LOG_CTX("Recompilation of module \"w\" failed.", NULL);
-    assert_null(mod2);
-    ly_in_free(in, 0);
-#endif
-
     assert_int_equal(LY_SUCCESS, ly_in_new_memory("module z {namespace urn:z;prefix z;import w {prefix w;revision-date 2018-10-24;}}", &in));
     ly_ctx_set_module_imp_clb(UTEST_LYCTX, test_imp_clb, "module w {namespace urn:w;prefix w;revision 2018-10-24;}");
     assert_int_equal(LY_SUCCESS, lys_parse(UTEST_LYCTX, in, LYS_IN_YANG, NULL, &mod2));
@@ -425,6 +412,7 @@ test_imports(void **state)
             "import a {prefix a;}"
             "}";
     assert_int_equal(LY_EVALID, lys_parse_mem(UTEST_LYCTX, str, LYS_IN_YANG, NULL));
+    ly_err_clean(UTEST_LYCTX, NULL);
 }
 
 static void
diff --git a/tests/utests/basic/test_hash_table.c b/tests/utests/basic/test_hash_table.c
index 25b595a..78950cd 100644
--- a/tests/utests/basic/test_hash_table.c
+++ b/tests/utests/basic/test_hash_table.c
@@ -1,4 +1,4 @@
-/*
+/**
  * @file test_hash_table.c
  * @author: Radek Krejci <rkrejci@cesnet.cz>
  * @brief unit tests for functions from hash_table.c
@@ -19,8 +19,6 @@
 #include "common.h"
 #include "hash_table.h"
 
-struct ht_rec *lyht_get_rec(unsigned char *recs, uint16_t rec_size, uint32_t idx);
-
 static void
 test_invalid_arguments(void **state)
 {
@@ -83,7 +81,7 @@ static void
 test_ht_basic(void **state)
 {
     uint32_t i;
-    struct hash_table *ht;
+    struct ly_ht *ht;
 
     assert_non_null(ht = lyht_new(8, sizeof(int), ht_equal_clb, NULL, 0));
 
@@ -96,15 +94,14 @@ test_ht_basic(void **state)
     assert_int_equal(LY_ENOTFOUND, lyht_remove(ht, &i, i));
     CHECK_LOG("Invalid argument hash (lyht_remove_with_resize_cb()).", NULL);
 
-    lyht_free(ht);
+    lyht_free(ht, NULL);
 }
 
 static void
 test_ht_resize(void **state)
 {
     uint32_t i;
-    struct ht_rec *rec;
-    struct hash_table *ht;
+    struct ly_ht *ht;
 
     assert_non_null(ht = lyht_new(8, sizeof(int), ht_equal_clb, NULL, 1));
     assert_int_equal(8, ht->size);
@@ -120,13 +117,12 @@ test_ht_resize(void **state)
     for (i = 0; i < 16; ++i) {
         if ((i >= 2) && (i < 8)) {
             /* inserted data on indexes 2-7 */
-            rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-            assert_int_equal(1, rec->hits);
-            assert_int_equal(i, rec->hash);
+            assert_int_not_equal(UINT32_MAX, ht->hlists[i].first);
+            assert_int_equal(LY_SUCCESS, lyht_find(ht, &i, i, NULL));
         } else {
             /* nothing otherwise */
-            rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-            assert_int_equal(0, rec->hits);
+            assert_int_equal(UINT32_MAX, ht->hlists[i].first);
+            assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, i, NULL));
         }
     }
 
@@ -153,7 +149,7 @@ test_ht_resize(void **state)
     }
 
     /* cleanup */
-    lyht_free(ht);
+    lyht_free(ht, NULL);
 }
 
 static void
@@ -162,8 +158,10 @@ test_ht_collisions(void **UNUSED(state))
 #define GET_REC_INT(rec) (*((uint32_t *)&(rec)->val))
 
     uint32_t i;
-    struct ht_rec *rec;
-    struct hash_table *ht;
+    struct ly_ht_rec *rec;
+    struct ly_ht *ht;
+    uint32_t rec_idx;
+    int count;
 
     assert_non_null(ht = lyht_new(8, sizeof(int), ht_equal_clb, NULL, 1));
 
@@ -172,66 +170,69 @@ test_ht_collisions(void **UNUSED(state))
     }
 
     /* check all records */
-    for (i = 0; i < 2; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, 0);
+    for (i = 0; i < 8; ++i) {
+        if (i == 2) {
+            assert_int_not_equal(UINT32_MAX, ht->hlists[i].first);
+        } else {
+            assert_int_equal(UINT32_MAX, ht->hlists[i].first);
+        }
     }
-    rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-    assert_int_equal(rec->hits, 4);
-    assert_int_equal(GET_REC_INT(rec), i);
-    ++i;
-    for ( ; i < 6; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, 1);
-        assert_int_equal(GET_REC_INT(rec), i);
+    for (i = 0; i < 8; ++i) {
+        if ((i >= 2) && (i < 6)) {
+            assert_int_equal(LY_SUCCESS, lyht_find(ht, &i, 2, NULL));
+        } else {
+            assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, 2, NULL));
+        }
     }
-    for ( ; i < 8; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, 0);
+    rec_idx = ht->hlists[2].first;
+    count = 0;
+    while (rec_idx != UINT32_MAX) {
+        rec = lyht_get_rec(ht->recs, ht->rec_size, rec_idx);
+        rec_idx = rec->next;
+        assert_int_equal(rec->hash, 2);
+        count++;
     }
+    assert_int_equal(count, 4);
 
     i = 4;
     assert_int_equal(lyht_remove(ht, &i, 2), 0);
 
     rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-    assert_int_equal(rec->hits, -1);
 
     i = 2;
     assert_int_equal(lyht_remove(ht, &i, 2), 0);
 
     /* check all records */
-    for (i = 0; i < 2; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, 0);
+    for (i = 0; i < 8; ++i) {
+        if (i == 2) {
+            assert_int_not_equal(UINT32_MAX, ht->hlists[i].first);
+        } else {
+            assert_int_equal(UINT32_MAX, ht->hlists[i].first);
+        }
     }
-    rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-    assert_int_equal(rec->hits, 2);
-    assert_int_equal(GET_REC_INT(rec), 5);
-    ++i;
-    rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-    assert_int_equal(rec->hits, 1);
-    assert_int_equal(GET_REC_INT(rec), 3);
-    ++i;
-    for ( ; i < 6; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, -1);
+    for (i = 0; i < 8; ++i) {
+        if ((i == 3) || (i == 5)) {
+            assert_int_equal(LY_SUCCESS, lyht_find(ht, &i, 2, NULL));
+        } else {
+            assert_int_equal(LY_ENOTFOUND, lyht_find(ht, &i, 2, NULL));
+        }
     }
-    for ( ; i < 8; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, 0);
+    rec_idx = ht->hlists[2].first;
+    count = 0;
+    while (rec_idx != UINT32_MAX) {
+        rec = lyht_get_rec(ht->recs, ht->rec_size, rec_idx);
+        rec_idx = rec->next;
+        assert_int_equal(rec->hash, 2);
+        count++;
     }
+    assert_int_equal(count, 2);
 
-    for (i = 0; i < 3; ++i) {
-        assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_ENOTFOUND);
-    }
-    assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_SUCCESS);
-    ++i;
-    assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_ENOTFOUND);
-    ++i;
-    assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_SUCCESS);
-    ++i;
-    for ( ; i < 8; ++i) {
-        assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_ENOTFOUND);
+    for (i = 0; i < 8; ++i) {
+        if ((i == 3) || (i == 5)) {
+            assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_SUCCESS);
+        } else {
+            assert_int_equal(lyht_find(ht, &i, 2, NULL), LY_ENOTFOUND);
+        }
     }
 
     i = 3;
@@ -240,20 +241,11 @@ test_ht_collisions(void **UNUSED(state))
     assert_int_equal(lyht_remove(ht, &i, 2), 0);
 
     /* check all records */
-    for (i = 0; i < 2; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, 0);
-    }
-    for ( ; i < 6; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, -1);
-    }
-    for ( ; i < 8; ++i) {
-        rec = lyht_get_rec(ht->recs, ht->rec_size, i);
-        assert_int_equal(rec->hits, 0);
+    for (i = 0; i < 8; ++i) {
+        assert_int_equal(UINT32_MAX, ht->hlists[i].first);
     }
 
-    lyht_free(ht);
+    lyht_free(ht, NULL);
 }
 
 int
diff --git a/tests/utests/basic/test_inout.c b/tests/utests/basic/test_inout.c
index be27510..3f83568 100644
--- a/tests/utests/basic/test_inout.c
+++ b/tests/utests/basic/test_inout.c
@@ -84,8 +84,11 @@ test_input_mem(void **UNUSED(state))
     char *str1 = "a", *str2 = "b";
 
     assert_int_equal(LY_EINVAL, ly_in_new_memory(NULL, NULL));
+    CHECK_LOG_LASTMSG("Invalid argument str (ly_in_new_memory()).");
     assert_int_equal(LY_EINVAL, ly_in_new_memory(str1, NULL));
+    CHECK_LOG_LASTMSG("Invalid argument in (ly_in_new_memory()).");
     assert_null(ly_in_memory(NULL, NULL));
+    CHECK_LOG_LASTMSG("Invalid argument in (ly_in_memory()).");
 
     assert_int_equal(LY_SUCCESS, ly_in_new_memory(str1, &in));
     assert_int_equal(LY_IN_MEMORY, ly_in_type(in));
@@ -103,12 +106,15 @@ test_input_fd(void **UNUSED(state))
     struct stat statbuf;
 
     assert_int_equal(LY_EINVAL, ly_in_new_fd(-1, NULL));
+    CHECK_LOG_LASTMSG("Invalid argument fd >= 0 (ly_in_new_fd()).");
     assert_int_equal(-1, ly_in_fd(NULL, -1));
+    CHECK_LOG_LASTMSG("Invalid argument in (ly_in_fd()).");
 
     assert_int_not_equal(-1, fd1 = open(TEST_INPUT_FILE, O_RDONLY));
     assert_int_not_equal(-1, fd2 = open(TEST_INPUT_FILE, O_RDONLY));
 
     assert_int_equal(LY_EINVAL, ly_in_new_fd(fd1, NULL));
+    CHECK_LOG_LASTMSG("Invalid argument in (ly_in_new_fd()).");
 
     assert_int_equal(LY_SUCCESS, ly_in_new_fd(fd1, &in));
     assert_int_equal(LY_IN_FD, ly_in_type(in));
diff --git a/tests/utests/basic/test_json.c b/tests/utests/basic/test_json.c
index 1896b8a..08b7719 100644
--- a/tests/utests/basic/test_json.c
+++ b/tests/utests/basic/test_json.c
@@ -1,4 +1,4 @@
-/*
+/**
  * @file test_json.c
  * @author: Radek Krejci <rkrejci@cesnet.cz>
  * @brief unit tests for a generic JSON parser
@@ -27,39 +27,40 @@ test_general(void **state)
     /* empty */
     str = "";
     assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
-    lyjson_ctx_free(jsonctx);
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    CHECK_LOG_CTX("Empty JSON file.", "Line number 1.");
 
     str = "  \n\t \n";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
-    lyjson_ctx_free(jsonctx);
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    CHECK_LOG_CTX("Empty JSON file.", "Line number 3.");
 
     /* constant values */
     str = "true";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_TRUE, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_TRUE, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     str = "false";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_FALSE, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_FALSE, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     str = "null";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     ly_in_free(in, 0);
@@ -75,8 +76,8 @@ test_number(void **state)
     /* simple value */
     str = "11";
     assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("11", jsonctx->value);
     assert_int_equal(2, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
@@ -85,8 +86,8 @@ test_number(void **state)
     /* fraction number */
     str = "37.7668";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("37.7668", jsonctx->value);
     assert_int_equal(7, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
@@ -95,8 +96,8 @@ test_number(void **state)
     /* negative number */
     str = "-122.3959";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("-122.3959", jsonctx->value);
     assert_int_equal(9, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
@@ -105,8 +106,8 @@ test_number(void **state)
     /* integer, positive exponent */
     str = "550E3";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("550000", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -114,8 +115,8 @@ test_number(void **state)
 
     str = "-550E3";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("-550000", jsonctx->value);
     assert_int_equal(7, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -124,8 +125,8 @@ test_number(void **state)
     /* integer, negative exponent */
     str = "1E-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.1", jsonctx->value);
     assert_int_equal(3, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -133,8 +134,8 @@ test_number(void **state)
 
     str = "15E-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("1.5", jsonctx->value);
     assert_int_equal(3, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -142,8 +143,8 @@ test_number(void **state)
 
     str = "-15E-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("-1.5", jsonctx->value);
     assert_int_equal(4, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -151,8 +152,8 @@ test_number(void **state)
 
     str = "16E-2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.16", jsonctx->value);
     assert_int_equal(4, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -160,8 +161,8 @@ test_number(void **state)
 
     str = "-16E-2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("-0.16", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -169,8 +170,8 @@ test_number(void **state)
 
     str = "17E-3";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.017", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -178,8 +179,8 @@ test_number(void **state)
 
     str = "-17E-3";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("-0.017", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -187,8 +188,8 @@ test_number(void **state)
 
     str = "21000E-2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("210", jsonctx->value);
     assert_int_equal(3, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -196,8 +197,8 @@ test_number(void **state)
 
     str = "21000E-4";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("2.1", jsonctx->value);
     assert_int_equal(3, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -205,8 +206,8 @@ test_number(void **state)
 
     str = "21000E-7";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.0021", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -215,8 +216,8 @@ test_number(void **state)
     /* decimal number, positive exponent */
     str = "5.087E1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("50.87", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -224,8 +225,8 @@ test_number(void **state)
 
     str = "-5.087E1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("-50.87", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -233,8 +234,8 @@ test_number(void **state)
 
     str = "5.087E5";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("508700", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -242,8 +243,8 @@ test_number(void **state)
 
     str = "59.1e+1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("591", jsonctx->value);
     assert_int_equal(3, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -251,8 +252,8 @@ test_number(void **state)
 
     str = "0.005087E1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.05087", jsonctx->value);
     assert_int_equal(7, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -260,8 +261,8 @@ test_number(void **state)
 
     str = "0.005087E2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.5087", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -269,8 +270,8 @@ test_number(void **state)
 
     str = "0.005087E6";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("5087", jsonctx->value);
     assert_int_equal(4, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -278,8 +279,8 @@ test_number(void **state)
 
     str = "0.05087E6";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("50870", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -287,8 +288,8 @@ test_number(void **state)
 
     str = "0.005087E8";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("508700", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -297,8 +298,8 @@ test_number(void **state)
     /* decimal number, negative exponent */
     str = "35.94e-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("3.594", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -306,8 +307,8 @@ test_number(void **state)
 
     str = "-35.94e-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("-3.594", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -315,8 +316,8 @@ test_number(void **state)
 
     str = "35.94e-2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.3594", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -324,8 +325,8 @@ test_number(void **state)
 
     str = "35.94e-3";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.03594", jsonctx->value);
     assert_int_equal(7, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -333,8 +334,8 @@ test_number(void **state)
 
     str = "0.3594e-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.03594", jsonctx->value);
     assert_int_equal(7, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -342,8 +343,8 @@ test_number(void **state)
 
     str = "0.03594e-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.003594", jsonctx->value);
     assert_int_equal(8, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -351,8 +352,8 @@ test_number(void **state)
 
     str = "0.003594e-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.0003594", jsonctx->value);
     assert_int_equal(9, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -360,8 +361,8 @@ test_number(void **state)
 
     str = "0.3594e-2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.003594", jsonctx->value);
     assert_int_equal(8, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -369,8 +370,8 @@ test_number(void **state)
 
     str = "0.03594e-2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.0003594", jsonctx->value);
     assert_int_equal(9, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -378,8 +379,8 @@ test_number(void **state)
 
     str = "0.003594e-2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.00003594", jsonctx->value);
     assert_int_equal(10, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -388,8 +389,8 @@ test_number(void **state)
     /* zero */
     str = "0";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_true(jsonctx->value[0] == '0');
     assert_int_equal(1, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
@@ -397,8 +398,8 @@ test_number(void **state)
 
     str = "-0";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_true(jsonctx->value[0] == '-');
     assert_true(jsonctx->value[1] == '0');
     assert_int_equal(2, jsonctx->value_len);
@@ -407,8 +408,8 @@ test_number(void **state)
 
     str = "94E0";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_true(jsonctx->value[0] == '9');
     assert_true(jsonctx->value[1] == '4');
     assert_int_equal(2, jsonctx->value_len);
@@ -417,8 +418,8 @@ test_number(void **state)
 
     str = "0E2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_true(jsonctx->value[0] == '0');
     assert_int_equal(1, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
@@ -426,8 +427,8 @@ test_number(void **state)
 
     str = "-0E2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_true(jsonctx->value[0] == '-');
     assert_true(jsonctx->value[1] == '0');
     assert_int_equal(2, jsonctx->value_len);
@@ -436,8 +437,8 @@ test_number(void **state)
 
     str = "5.320e+2";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("532", jsonctx->value);
     assert_int_equal(3, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -445,8 +446,8 @@ test_number(void **state)
 
     str = "5.320e-1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_NUMBER, lyjson_ctx_status(jsonctx));
     assert_string_equal("0.532", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(1, jsonctx->dynamic);
@@ -455,69 +456,64 @@ test_number(void **state)
     /* various invalid inputs */
     str = "-x";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Invalid character in JSON Number value (\"x\").", "Line number 1.");
 
     str = "  -";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Unexpected end-of-input.", "Line number 1.");
 
     str = "--1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Invalid character in JSON Number value (\"-\").", "Line number 1.");
 
     str = "+1";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Invalid character sequence \"+1\", expected a JSON value.", "Line number 1.");
 
     str = "  1.x ";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Invalid character in JSON Number value (\"x\").", "Line number 1.");
 
     str = "1.";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Unexpected end-of-input.", "Line number 1.");
 
     str = "  1eo ";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Invalid character in JSON Number value (\"o\").", "Line number 1.");
 
     str = "1e";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Unexpected end-of-input.", "Line number 1.");
 
     str = "1E1000";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Number encoded as a string exceeded the LY_NUMBER_MAXLEN limit.", "Line number 1.");
 
     str = "1e9999999999999999999";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Exponent out-of-bounds in a JSON Number value (1e9999999999999999999).", "Line number 1.");
 
     str = "1.1e66000";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Exponent out-of-bounds in a JSON Number value (1.1e66000).", "Line number 1.");
 
     str = "1.1e-66000";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Exponent out-of-bounds in a JSON Number value (1.1e-66000).", "Line number 1.");
 
-    str = "-2.1e0.";
-    assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    CHECK_LOG_CTX("Unexpected character \".\" after JSON number.", "Line number 1.");
-
     ly_in_free(in, 0);
 }
 
@@ -532,68 +528,12 @@ test_string(void **state)
     str = "";
     assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in));
 
-#if 0
-    /* simple string */
-    str = "\"hello\"";
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx, 0));
-    assert_ptr_equal(&str[1], jsonctx->value);
-    assert_int_equal(5, jsonctx->value_len);
-    assert_int_equal(0, jsonctx->dynamic);
-    lyjson_ctx_free(jsonctx);
-
-    /* 4-byte utf8 character */
-    str = "\"\\t𠜎\"";
-    assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal("\t𠜎", jsonctx->value);
-    assert_int_equal(5, jsonctx->value_len);
-    assert_int_equal(1, jsonctx->dynamic);
-    lyjson_ctx_free(jsonctx);
-
-    /* valid escape sequences - note that here it mixes valid JSON string characters (RFC 7159, sec. 7) and
-     * valid characters in YANG string type (RFC 7950, sec. 9.4). Since the latter is a subset of JSON string,
-     * the YANG string type's restrictions apply to the JSON escape sequences */
-    str = "\"\\\" \\\\ \\r \\/ \\n \\t \\u20ac\"";
-    assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal("\" \\ \r / \n \t €", jsonctx->value);
-    assert_int_equal(15, jsonctx->value_len);
-    assert_int_equal(1, jsonctx->dynamic);
-    lyjson_ctx_free(jsonctx);
-
-    /* backspace and form feed are valid JSON escape sequences, but the control characters they represents are not allowed values for YANG string type */
-    str = "\"\\b\"";
-    assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    CHECK_LOG_CTX("Invalid character reference \"\\b\" (0x00000008).", "Line number 1.");
-
-    str = "\"\\f\"";
-    assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    CHECK_LOG_CTX("Invalid character reference \"\\f\" (0x0000000c).", "Line number 1.");
-#endif
-
     /* unterminated string */
     str = "\"unterminated string";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     CHECK_LOG_CTX("Missing quotation-mark at the end of a JSON string.", "Line number 1.");
-#if 0
-    /* invalid escape sequence */
-    str = "\"char \\x \"";
-    assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    CHECK_LOG_CTX("Invalid character escape sequence \\x.", "Line number 1.");
-
-    /* new line is allowed only as escaped character in JSON */
-    str = "\"\n\"";
-    assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    CHECK_LOG_CTX("Invalid character in JSON string \"\n\" (0x0000000a).", "Line number 1.");
-#endif
+    CHECK_LOG_CTX("Unexpected end-of-input.", "Line number 1.");
 
     ly_in_free(in, 0);
 }
@@ -608,95 +548,122 @@ test_object(void **state)
     /* empty */
     str = "  { }  ";
     assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_OBJECT_EMPTY, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     /* simple value */
     str = "{\"name\" : \"Radek\"}";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx, 0));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx));
     assert_ptr_equal(&str[2], jsonctx->value);
     assert_int_equal(4, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("\"Radek\"}", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx));
     assert_string_equal("Radek\"}", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("}", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     /* two values */
     str = "{\"smart\" : true,\"handsom\":false}";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx));
     assert_string_equal("smart\" : true,\"handsom\":false}", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("true,\"handsom\":false}", jsonctx->in->current);
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_TRUE, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_TRUE, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal(",\"handsom\":false}", jsonctx->in->current);
+    assert_int_equal(LYJSON_OBJECT_NEXT, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx));
     assert_string_equal("handsom\":false}", jsonctx->value);
     assert_int_equal(7, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("false}", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_FALSE, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal("}", jsonctx->in->current);
+    assert_int_equal(LYJSON_FALSE, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     /* inherited objects */
     str = "{\"person\" : {\"name\":\"Radek\"}}";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx));
     assert_string_equal("person\" : {\"name\":\"Radek\"}}", jsonctx->value);
     assert_int_equal(6, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("{\"name\":\"Radek\"}}", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx));
     assert_string_equal("name\":\"Radek\"}}", jsonctx->value);
     assert_int_equal(4, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("\"Radek\"}}", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx));
     assert_string_equal("Radek\"}}", jsonctx->value);
     assert_int_equal(5, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("}}", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal("}", jsonctx->in->current);
+    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
-    /* new line is allowed only as escaped character in JSON */
+    /* unquoted string */
     str = "{ unquoted : \"data\"}";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_EVALID, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    CHECK_LOG_CTX("Invalid character sequence \"unquoted : \"data\"}\", expected a JSON object's member.", "Line number 1.");
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_EVALID, lyjson_ctx_next(jsonctx, NULL));
+    CHECK_LOG_CTX("Invalid character sequence \"unquoted : \"data\"}\", expected a JSON object name.", "Line number 1.");
+    lyjson_ctx_free(jsonctx);
 
     ly_in_free(in, 0);
 }
@@ -711,67 +678,79 @@ test_array(void **state)
     /* empty */
     str = "  [  ]  ";
     assert_int_equal(LY_SUCCESS, ly_in_new_memory(str, &in));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_ARRAY_EMPTY, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     /* simple value */
     str = "[ null]";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx));
     assert_null(jsonctx->value);
     assert_int_equal(0, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("null]", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal("]", jsonctx->in->current);
+    assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     /* two values */
     str = "[{\"a\":null},\"x\"]";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
-    assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
+    assert_int_equal(LYJSON_ARRAY, lyjson_ctx_status(jsonctx));
     assert_null(jsonctx->value);
     assert_int_equal(0, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("{\"a\":null},\"x\"]", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_OBJECT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_OBJECT_NAME, lyjson_ctx_status(jsonctx));
     assert_string_equal("a\":null},\"x\"]", jsonctx->value);
     assert_int_equal(1, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("null},\"x\"]", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal("},\"x\"]", jsonctx->in->current);
+    assert_int_equal(LYJSON_NULL, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx, 0));
-    assert_string_equal(",\"x\"]", jsonctx->in->current);
+    assert_int_equal(LYJSON_OBJECT_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_ARRAY_NEXT, lyjson_ctx_status(jsonctx));
+
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
+    assert_int_equal(LYJSON_STRING, lyjson_ctx_status(jsonctx));
     assert_string_equal("x\"]", jsonctx->value);
     assert_int_equal(1, jsonctx->value_len);
     assert_int_equal(0, jsonctx->dynamic);
-    assert_string_equal("]", jsonctx->in->current);
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_ARRAY_CLOSED, lyjson_ctx_status(jsonctx));
+
     assert_int_equal(LY_SUCCESS, lyjson_ctx_next(jsonctx, NULL));
-    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx, 0));
+    assert_int_equal(LYJSON_END, lyjson_ctx_status(jsonctx));
     lyjson_ctx_free(jsonctx);
 
     /* new line is allowed only as escaped character in JSON */
     str = "[ , null]";
     assert_non_null(ly_in_memory(in, str));
-    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, 0, &jsonctx));
+    assert_int_equal(LY_SUCCESS, lyjson_ctx_new(UTEST_LYCTX, in, &jsonctx));
     assert_int_equal(LY_EVALID, lyjson_ctx_next(jsonctx, NULL));
     CHECK_LOG_CTX("Invalid character sequence \", null]\", expected a JSON value.", "Line number 1.");
     lyjson_ctx_free(jsonctx);
diff --git a/tests/utests/basic/test_plugins.c b/tests/utests/basic/test_plugins.c
index 7f3fe40..de13c0b 100644
--- a/tests/utests/basic/test_plugins.c
+++ b/tests/utests/basic/test_plugins.c
@@ -1,4 +1,4 @@
-/*
+/**
  * @file test_plugins.c
  * @author: Radek Krejci <rkrejci@cesnet.cz>
  * @brief unit tests for functions from set.c
diff --git a/tests/utests/basic/test_set.c b/tests/utests/basic/test_set.c
index af39afa..9485927 100644
--- a/tests/utests/basic/test_set.c
+++ b/tests/utests/basic/test_set.c
@@ -1,4 +1,4 @@
-/*
+/**
  * @file test_set.c
  * @author: Radek Krejci <rkrejci@cesnet.cz>
  * @brief unit tests for functions from set.c
diff --git a/tests/utests/basic/test_xml.c b/tests/utests/basic/test_xml.c
index 668de4b..071846a 100644
--- a/tests/utests/basic/test_xml.c
+++ b/tests/utests/basic/test_xml.c
@@ -1,4 +1,4 @@
-/*
+/**
  * @file test_xml.c
  * @author: Radek Krejci <rkrejci@cesnet.cz>
  * @brief unit tests for functions from xml.c
diff --git a/tests/utests/basic/test_xpath.c b/tests/utests/basic/test_xpath.c
index b388dc3..754abf2 100644
--- a/tests/utests/basic/test_xpath.c
+++ b/tests/utests/basic/test_xpath.c
@@ -88,6 +88,19 @@ const char *schema_a =
         "            type string;\n"
         "        }\n"
         "    }\n"
+        "\n"
+        "    rpc r {\n"
+        "        input {\n"
+        "            leaf l {\n"
+        "                type string;\n"
+        "            }\n"
+        "        }\n"
+        "        output {\n"
+        "            leaf l {\n"
+        "                type string;\n"
+        "            }\n"
+        "        }\n"
+        "    }\n"
         "}";
 
 static int
@@ -254,9 +267,11 @@ test_invalid(void **state)
 
     assert_int_equal(LY_EVALID, lyd_find_xpath(tree, "/a:foo2[.=]", &set));
     assert_null(set);
+    CHECK_LOG_CTX("Unexpected XPath token \"]\" (\"]\").", NULL);
 
     assert_int_equal(LY_EVALID, lyd_find_xpath(tree, "/a:", &set));
     assert_null(set);
+    CHECK_LOG_CTX("Invalid character 'a'[2] of expression '/a:'.", NULL);
 
     lyd_free_all(tree);
 }
@@ -381,6 +396,31 @@ test_hash(void **state)
 }
 
 static void
+test_rpc(void **state)
+{
+    const char *data =
+            "<r xmlns=\"urn:tests:a\">\n"
+            "    <l>val</l>\n"
+            "</r>";
+    struct ly_in *in;
+    struct lyd_node *tree;
+    struct ly_set *set;
+
+    assert_int_equal(LY_SUCCESS, ly_in_new_memory(data, &in));
+    assert_int_equal(LY_SUCCESS, lyd_parse_op(UTEST_LYCTX, NULL, in, LYD_XML, LYD_TYPE_REPLY_YANG, &tree, NULL));
+    ly_in_free(in, 0);
+    assert_non_null(tree);
+
+    /* name collision input/output, hashes are not used */
+    assert_int_equal(LY_SUCCESS, lyd_find_xpath(tree, "/a:r/l", &set));
+    assert_int_equal(1, set->count);
+
+    ly_set_free(set, NULL);
+
+    lyd_free_all(tree);
+}
+
+static void
 test_toplevel(void **state)
 {
     const char *schema_b =
@@ -479,7 +519,7 @@ test_atomize(void **state)
 
     /* some random paths just making sure the API function works */
     assert_int_equal(LY_SUCCESS, lys_find_xpath_atoms(UTEST_LYCTX, NULL, "/a:*", 0, &set));
-    assert_int_equal(6, set->count);
+    assert_int_equal(7, set->count);
     ly_set_free(set, NULL);
 
     /* all nodes from all modules (including internal, which can change easily, so check just the test modules) */
@@ -496,7 +536,7 @@ test_atomize(void **state)
     ly_set_free(set, NULL);
 
     assert_int_equal(LY_SUCCESS, lys_find_xpath_atoms(UTEST_LYCTX, NULL, "/*", 0, &set));
-    assert_int_equal(13, set->count);
+    assert_int_equal(14, set->count);
     ly_set_free(set, NULL);
 
     /*
@@ -530,7 +570,7 @@ test_atomize(void **state)
 
     /* descendant-or-self */
     assert_int_equal(LY_SUCCESS, lys_find_xpath_atoms(UTEST_LYCTX, NULL, "/a:*/descendant-or-self::c", 0, &set));
-    assert_int_equal(7, set->count);
+    assert_int_equal(8, set->count);
     ly_set_free(set, NULL);
 
     /* following */
@@ -545,11 +585,11 @@ test_atomize(void **state)
 
     /* parent */
     assert_int_equal(LY_SUCCESS, lys_find_xpath_atoms(UTEST_LYCTX, NULL, "/child::a:*/c/parent::l1", 0, &set));
-    assert_int_equal(7, set->count);
+    assert_int_equal(8, set->count);
     ly_set_free(set, NULL);
 
     assert_int_equal(LY_SUCCESS, lys_find_xpath_atoms(UTEST_LYCTX, NULL, "/child::a:c//..", 0, &set));
-    assert_int_equal(8, set->count);
+    assert_int_equal(11, set->count);
     ly_set_free(set, NULL);
 
     /* preceding */
@@ -898,6 +938,7 @@ test_variables(void **state)
     LOCAL_SETUP(data, tree);
     assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var1", "\"mstr\""));
     assert_int_equal(LY_ENOTFOUND, lyd_find_xpath2(tree, "/foo[text() = $var55]", vars, &set));
+    CHECK_LOG_CTX("Variable \"var55\" not defined.", NULL);
     LOCAL_TEARDOWN(set, tree, vars);
 
     /* Syntax error in value. */
@@ -906,6 +947,7 @@ test_variables(void **state)
     LOCAL_SETUP(data, tree);
     assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var", "\""));
     assert_int_equal(LY_EVALID, lyd_find_xpath2(tree, "/foo[$var]", vars, &set));
+    CHECK_LOG_CTX("Unterminated string delimited with \" (\").", "Data location \"/a:foo\".");
     LOCAL_TEARDOWN(set, tree, vars);
 
     /* Prefix is not supported. */
@@ -914,7 +956,7 @@ test_variables(void **state)
     LOCAL_SETUP(data, tree);
     assert_int_equal(LY_SUCCESS, lyxp_vars_set(&vars, "var", "\""));
     assert_int_equal(LY_EVALID, lyd_find_xpath2(tree, "/foo[$pref:var]", vars, &set));
-    assert_string_equal("Variable with prefix is not supported.", _UC->err_msg);
+    CHECK_LOG_CTX("Variable with prefix is not supported.", NULL);
     LOCAL_TEARDOWN(set, tree, vars);
 
 #undef LOCAL_SETUP
@@ -1050,6 +1092,154 @@ test_axes(void **state)
     lyd_free_all(tree);
 }
 
+static void
+test_trim(void **state)
+{
+    const char *data;
+    char *str1;
+    struct lyd_node *tree;
+
+    data =
+            "<l1 xmlns=\"urn:tests:a\">"
+            "  <a>a1</a>"
+            "  <b>b1</b>"
+            "  <c>c1</c>"
+            "</l1>"
+            "<l1 xmlns=\"urn:tests:a\">"
+            "  <a>a2</a>"
+            "  <b>b2</b>"
+            "</l1>"
+            "<l1 xmlns=\"urn:tests:a\">"
+            "  <a>a3</a>"
+            "  <b>b3</b>"
+            "</l1>"
+            "<l1 xmlns=\"urn:tests:a\">"
+            "  <a>a4</a>"
+            "  <b>b4</b>"
+            "  <c>c4</c>"
+            "</l1>"
+            "<l1 xmlns=\"urn:tests:a\">"
+            "  <a>a5</a>"
+            "  <b>b5</b>"
+            "  <c>c5</c>"
+            "</l1>"
+            "<foo2 xmlns=\"urn:tests:a\">50</foo2>"
+            "<c xmlns=\"urn:tests:a\">"
+            "  <x>key2</x>"
+            "  <ll>"
+            "    <a>key1</a>"
+            "    <ll>"
+            "      <a>key11</a>"
+            "      <b>val11</b>"
+            "    </ll>"
+            "    <ll>"
+            "      <a>key12</a>"
+            "      <b>val12</b>"
+            "    </ll>"
+            "    <ll>"
+            "      <a>key13</a>"
+            "      <b>val13</b>"
+            "    </ll>"
+            "  </ll>"
+            "  <ll>"
+            "    <a>key2</a>"
+            "    <ll>"
+            "      <a>key21</a>"
+            "      <b>val21</b>"
+            "    </ll>"
+            "    <ll>"
+            "      <a>key22</a>"
+            "      <b>val22</b>"
+            "    </ll>"
+            "  </ll>"
+            "  <ll>"
+            "    <a>key3</a>"
+            "    <ll>"
+            "      <a>key31</a>"
+            "      <b>val31</b>"
+            "    </ll>"
+            "    <ll>"
+            "      <a>key32</a>"
+            "      <b>val32</b>"
+            "    </ll>"
+            "  </ll>"
+            "</c>";
+
+    /* trim #1 */
+    assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, &tree));
+    assert_non_null(tree);
+
+    assert_int_equal(LY_SUCCESS, lyd_trim_xpath(&tree, "/a:c/ll/ll[a='key11']", NULL));
+    lyd_print_mem(&str1, tree, LYD_XML, LYD_PRINT_WITHSIBLINGS);
+    assert_string_equal(str1,
+            "<c xmlns=\"urn:tests:a\">\n"
+            "  <ll>\n"
+            "    <a>key1</a>\n"
+            "    <ll>\n"
+            "      <a>key11</a>\n"
+            "      <b>val11</b>\n"
+            "    </ll>\n"
+            "  </ll>\n"
+            "</c>\n");
+
+    free(str1);
+    lyd_free_all(tree);
+
+    /* trim #2 */
+    assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, &tree));
+    assert_non_null(tree);
+
+    assert_int_equal(LY_SUCCESS, lyd_trim_xpath(&tree, "/a:c/ll/ll[contains(.,'2')]", NULL));
+    lyd_print_mem(&str1, tree, LYD_XML, LYD_PRINT_WITHSIBLINGS);
+    assert_string_equal(str1,
+            "<c xmlns=\"urn:tests:a\">\n"
+            "  <ll>\n"
+            "    <a>key1</a>\n"
+            "    <ll>\n"
+            "      <a>key12</a>\n"
+            "      <b>val12</b>\n"
+            "    </ll>\n"
+            "  </ll>\n"
+            "  <ll>\n"
+            "    <a>key2</a>\n"
+            "    <ll>\n"
+            "      <a>key21</a>\n"
+            "      <b>val21</b>\n"
+            "    </ll>\n"
+            "    <ll>\n"
+            "      <a>key22</a>\n"
+            "      <b>val22</b>\n"
+            "    </ll>\n"
+            "  </ll>\n"
+            "  <ll>\n"
+            "    <a>key3</a>\n"
+            "    <ll>\n"
+            "      <a>key32</a>\n"
+            "      <b>val32</b>\n"
+            "    </ll>\n"
+            "  </ll>\n"
+            "</c>\n");
+
+    free(str1);
+    lyd_free_all(tree);
+
+    /* trim #3 */
+    assert_int_equal(LY_SUCCESS, lyd_parse_data_mem(UTEST_LYCTX, data, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, &tree));
+    assert_non_null(tree);
+
+    assert_int_equal(LY_SUCCESS, lyd_trim_xpath(&tree, "/l1[4]//.", NULL));
+    lyd_print_mem(&str1, tree, LYD_XML, LYD_PRINT_WITHSIBLINGS);
+    assert_string_equal(str1,
+            "<l1 xmlns=\"urn:tests:a\">\n"
+            "  <a>a4</a>\n"
+            "  <b>b4</b>\n"
+            "  <c>c4</c>\n"
+            "</l1>\n");
+
+    free(str1);
+    lyd_free_all(tree);
+}
+
 int
 main(void)
 {
@@ -1058,6 +1248,7 @@ main(void)
         UTEST(test_union, setup),
         UTEST(test_invalid, setup),
         UTEST(test_hash, setup),
+        UTEST(test_rpc, setup),
         UTEST(test_toplevel, setup),
         UTEST(test_atomize, setup),
         UTEST(test_canonize, setup),
@@ -1065,6 +1256,7 @@ main(void)
         UTEST(test_augment, setup),
         UTEST(test_variables, setup),
         UTEST(test_axes, setup),
+        UTEST(test_trim, setup),
     };
 
     return cmocka_run_group_tests(tests, NULL, NULL);