automerge-rb 0.1.1

data/vendor/automerge-rust/automerge-c/test/cursor_tests.c

@@ -0,0 +1,263 @@
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include <automerge-c/automerge.h>
+#include <automerge-c/utils/stack_callback_data.h>
+#include "cmocka_utils.h"
+#include "doc_state.h"
+
+typedef struct {
+    DocState* doc_state;
+    AMobjId const* text;
+} TestState;
+
+static int setup(void** state) {
+    /* let mut doc = Automerge::new();                                                                                */
+    TestState* test_state = test_calloc(1, sizeof(TestState));
+    setup_doc((void**)&test_state->doc_state);
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    /* let mut tx = doc.transaction();
+       let text = tx.put_object(ROOT, "text", ObjType::Text)?;                                                        */
+    test_state->text = AMitemObjId(
+        AMstackItem(stack_ptr, AMmapPutObject(test_state->doc_state->doc, AM_ROOT, AMstr("text"), AM_OBJ_TYPE_TEXT),
+                    cmocka_cb, AMexpect(AM_VAL_TYPE_OBJ_TYPE)));
+    /* tx.commit();                                                                                                   */
+    AMstackItem(NULL, AMcommit(test_state->doc_state->doc, AMstr(NULL), NULL), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_CHANGE_HASH));
+    /* let mut tx = doc.transaction();
+       tx.splice_text(&text, 0, 0, "hello world")?;                                                                   */
+    AMstackItem(NULL, AMspliceText(test_state->doc_state->doc, test_state->text, 0, 0, AMstr("hello world")), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_VOID));
+    /* tx.commit();                                                                                                   */
+    AMstackItem(NULL, AMcommit(test_state->doc_state->doc, AMstr(NULL), NULL), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_CHANGE_HASH));
+    /* let mut tx = doc.transaction();
+       tx.splice_text(&text, 6, 0, "big bad ")?;                                                                      */
+    AMstackItem(NULL, AMspliceText(test_state->doc_state->doc, test_state->text, 6, 0, AMstr("big bad ")), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_VOID));
+    /* tx.commit();                                                                                                   */
+    AMstackItem(NULL, AMcommit(test_state->doc_state->doc, AMstr(NULL), NULL), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_CHANGE_HASH));
+    *state = test_state;
+    return 0;
+}
+
+static int teardown(void** state) {
+    TestState* test_state = *state;
+    teardown_doc((void**)&test_state->doc_state);
+    test_free(test_state);
+    return 0;
+}
+
+static void test_AMgetCursor(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    /* // simple cursor test + serialization
+       let cursor0 = doc.get_cursor(&text, 0, None).unwrap();                                                         */
+    AMcursor const* cursor0;
+    assert_true(
+        AMitemToCursor(AMstackItem(stack_ptr, AMgetCursor(test_state->doc_state->doc, test_state->text, 0, NULL),
+                                   cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+                       &cursor0));
+    /* let cursor0_str = cursor0.to_string();                                                                         */
+    AMbyteSpan const cursor0_str = AMcursorStr(cursor0);
+    assert_int_not_equal(cursor0_str.count, 0);
+    assert_non_null(cursor0_str.src);
+    /* let cursor0_bytes = cursor0.to_bytes();                                                                        */
+    AMbyteSpan const cursor0_bytes = AMcursorBytes(cursor0);
+    assert_int_not_equal(cursor0_bytes.count, 0);
+    assert_non_null(cursor0_bytes.src);
+    /* let pos0 = doc.get_cursor_position(&text, &cursor0, None).unwrap();                                            */
+    size_t pos0;
+    assert_true(AMitemToUint(
+        AMstackItem(stack_ptr, AMgetCursorPosition(test_state->doc_state->doc, test_state->text, cursor0, NULL),
+                    cmocka_cb, AMexpect(AM_VAL_TYPE_UINT)),
+        &pos0));
+    /* assert_eq!(pos0, 0);                                                                                           */
+    assert_int_equal(pos0, 0);
+    /* assert_eq!(Cursor::try_from(cursor0_str).unwrap(), cursor0);                                                   */
+    AMcursor const* cursor0_deserialized;
+    assert_true(
+        AMitemToCursor(AMstackItem(stack_ptr, AMcursorFromStr(cursor0_str), cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+                       &cursor0_deserialized));
+    assert_true(AMcursorEqual(cursor0_deserialized, cursor0));
+    /* assert_eq!(Cursor::try_from(cursor0_bytes).unwrap(), cursor0);                                                 */
+    assert_true(AMitemToCursor(AMstackItem(stack_ptr, AMcursorFromBytes(cursor0_bytes.src, cursor0_bytes.count),
+                                           cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+                               &cursor0_deserialized));
+    assert_true(AMcursorEqual(cursor0_deserialized, cursor0));
+}
+
+static void test_AMgetCursorPosition(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    /* // simple cursor test + serialization
+       let cursor1 = doc.get_cursor(&text, 6, None).unwrap();                                                         */
+    AMcursor const* cursor1;
+    assert_true(
+        AMitemToCursor(AMstackItem(stack_ptr, AMgetCursor(test_state->doc_state->doc, test_state->text, 6, NULL),
+                                   cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+                       &cursor1));
+    /* let cursor1_str = cursor1.to_string();                                                                         */
+    AMbyteSpan const cursor1_str = AMcursorStr(cursor1);
+    assert_int_not_equal(cursor1_str.count, 0);
+    assert_non_null(cursor1_str.src);
+    /* let cursor1_bytes = cursor1.to_bytes();                                                                        */
+    AMbyteSpan const cursor1_bytes = AMcursorBytes(cursor1);
+    assert_int_not_equal(cursor1_bytes.count, 0);
+    assert_non_null(cursor1_bytes.src);
+    /* let pos1 = doc.get_cursor_position(&text, &cursor1, None).unwrap();                                            */
+    size_t pos1;
+    assert_true(AMitemToUint(
+        AMstackItem(stack_ptr, AMgetCursorPosition(test_state->doc_state->doc, test_state->text, cursor1, NULL),
+                    cmocka_cb, AMexpect(AM_VAL_TYPE_UINT)),
+        &pos1));
+    /* assert_eq!(pos1, 6);                                                                                           */
+    assert_int_equal(pos1, 6);
+    /* assert_eq!(Cursor::try_from(cursor1_str).unwrap(), cursor1);                                                   */
+    AMcursor const* cursor1_deserialized;
+    assert_true(
+        AMitemToCursor(AMstackItem(stack_ptr, AMcursorFromStr(cursor1_str), cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+                       &cursor1_deserialized));
+    assert_true(AMcursorEqual(cursor1_deserialized, cursor1));
+    /* assert_eq!(Cursor::try_from(cursor1_bytes).unwrap(), cursor1);                                                 */
+    assert_true(AMitemToCursor(AMstackItem(stack_ptr, AMcursorFromBytes(cursor1_bytes.src, cursor1_bytes.count),
+                                           cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+                               &cursor1_deserialized));
+    assert_true(AMcursorEqual(cursor1_deserialized, cursor1));
+    /*
+       let heads0 = doc.get_heads();                                                                                  */
+    AMitems const heads0 =
+        AMstackItems(stack_ptr, AMgetHeads(test_state->doc_state->doc), cmocka_cb, AMexpect(AM_VAL_TYPE_CHANGE_HASH));
+    /*
+       let mut tx = doc.transaction();
+       tx.splice_text(&text, 3, 6, " new text ")?;                                                                    */
+    AMstackItem(NULL, AMspliceText(test_state->doc_state->doc, test_state->text, 3, 6, AMstr(" new text ")), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_VOID));
+    /* tx.commit();                                                                                                   */
+    AMstackItem(NULL, AMcommit(test_state->doc_state->doc, AMstr(NULL), NULL), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_CHANGE_HASH));
+    /*
+       // confirm the cursor changed position after an edit
+       let pos2 = doc.get_cursor_position(&text, &cursor1, None).unwrap();                                            */
+    size_t pos2;
+    assert_true(AMitemToUint(
+        AMstackItem(stack_ptr, AMgetCursorPosition(test_state->doc_state->doc, test_state->text, cursor1, NULL),
+                    cmocka_cb, AMexpect(AM_VAL_TYPE_UINT)),
+        &pos2));
+    /* assert_eq !(pos2, 13);  // -3 deleted & +10 inserted before cursor                                             */
+    assert_int_equal(pos2, 13);
+    /*
+       // confirm the cursor can still be read at the old position
+       let pos3 = doc.get_cursor_position(&text, &cursor1, Some(&heads0)).unwrap();                                   */
+    size_t pos3;
+    assert_true(AMitemToUint(
+        AMstackItem(stack_ptr, AMgetCursorPosition(test_state->doc_state->doc, test_state->text, cursor1, &heads0),
+                    cmocka_cb, AMexpect(AM_VAL_TYPE_UINT)),
+        &pos3));
+    /* assert_eq !(pos3, 6);  // back to the old heads                                                                */
+    assert_int_equal(pos3, 6);
+}
+
+static void test_AMcursorFromBytes_failure(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    /* // confirm cursor load errors
+       assert_eq!(
+        Cursor::try_from(vec![0u8, 3u8, 10u8].as_slice()),
+        Err(AutomergeError::InvalidCursorFormat)
+    );                                                                                                                */
+    uint8_t const BYTES[3] = {0, 3, 10};
+    AMresult* result = AMstackResult(stack_ptr, AMcursorFromBytes(BYTES, 3), NULL, NULL);
+    if (AMresultStatus(result) == AM_STATUS_OK) {
+        fail_msg("`AMcursor` from invalid array of bytes");
+    }
+}
+
+static void test_AMcursorFromStr_failure(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    /* assert_eq!(
+        Cursor::try_from("notacursor"),
+        Err(AutomergeError::InvalidCursorFormat)
+    );                                                                                                                */
+    AMresult* result = AMstackResult(stack_ptr, AMcursorFromStr(AMstr("notacursor")), NULL, NULL);
+    if (AMresultStatus(result) == AM_STATUS_OK) {
+        fail_msg("`AMcursor` from invalid UTF-8 string");
+    }
+}
+
+static void test_AMgetCursorPosition_failure(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    /* // confirm behavior of a invalid cursor
+       let bad_cursor = Cursor::try_from("10@aabbcc00").unwrap();                                                     */
+    AMcursor const* bad_cursor;
+    assert_true(AMitemToCursor(
+        AMstackItem(stack_ptr, AMcursorFromStr(AMstr("10@aabbcc00")), cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+        &bad_cursor));
+    /* assert_eq!(
+           doc.get_cursor_position(&text, &bad_cursor, None),
+           Err(AutomergeError::InvalidCursor(bad_cursor))
+       );                                                                                                             */
+    AMresult* result = AMstackResult(
+        stack_ptr, AMgetCursorPosition(test_state->doc_state->doc, test_state->text, bad_cursor, NULL), NULL, NULL);
+    if (AMresultStatus(result) == AM_STATUS_OK) {
+        fail_msg("position from invalid `AMcursor`");
+    }
+}
+
+static void test_AMgetCursor_failure(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    AMitems const heads0 =
+        AMstackItems(stack_ptr, AMgetHeads(test_state->doc_state->doc), cmocka_cb, AMexpect(AM_VAL_TYPE_CHANGE_HASH));
+    AMstackItem(NULL, AMspliceText(test_state->doc_state->doc, test_state->text, 3, 6, AMstr(" new text ")), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_VOID));
+    AMstackItem(NULL, AMcommit(test_state->doc_state->doc, AMstr(NULL), NULL), cmocka_cb,
+                AMexpect(AM_VAL_TYPE_CHANGE_HASH));
+    /* // cursors created after heads are invalid
+       let cursor3 = doc.get_cursor(&text, 6, None).unwrap();                                                         */
+    AMcursor const* cursor3;
+    assert_true(
+        AMitemToCursor(AMstackItem(stack_ptr, AMgetCursor(test_state->doc_state->doc, test_state->text, 6, NULL),
+                                   cmocka_cb, AMexpect(AM_VAL_TYPE_CURSOR)),
+                       &cursor3));
+    /* let pos4 = doc.get_cursor_position(&text, &cursor3, None).unwrap();                                            */
+    size_t pos4;
+    assert_true(AMitemToUint(
+        AMstackItem(stack_ptr, AMgetCursorPosition(test_state->doc_state->doc, test_state->text, cursor3, NULL),
+                    cmocka_cb, AMexpect(AM_VAL_TYPE_UINT)),
+        &pos4));
+    /* assert_eq!(pos4, 6);                                                                                           */
+    assert_int_equal(pos4, 6);
+    /* assert_eq!(
+           doc.get_cursor_position(&text, &cursor3, Some(&heads0)),
+           Err(AutomergeError::InvalidCursor(cursor3))
+    );                                                                                                                */
+    AMresult* result = AMstackResult(
+        stack_ptr, AMgetCursorPosition(test_state->doc_state->doc, test_state->text, cursor3, &heads0), NULL, NULL);
+    if (AMresultStatus(result) == AM_STATUS_OK) {
+        fail_msg("`AMcursor` from invalid heads");
+    }
+}
+
+int run_cursor_tests(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_AMgetCursor),
+        cmocka_unit_test(test_AMgetCursorPosition),
+        cmocka_unit_test(test_AMcursorFromBytes_failure),
+        cmocka_unit_test(test_AMcursorFromStr_failure),
+        cmocka_unit_test(test_AMgetCursorPosition_failure),
+        cmocka_unit_test(test_AMgetCursor_failure),
+    };
+
+    return cmocka_run_group_tests(tests, setup, teardown);
+}

data/vendor/automerge-rust/automerge-c/test/doc_state.c

@@ -0,0 +1,27 @@
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include <automerge-c/utils/stack_callback_data.h>
+#include "cmocka_utils.h"
+#include "doc_state.h"
+
+int setup_doc(void** state) {
+    DocState* doc_state = test_calloc(1, sizeof(DocState));
+    setup_base((void**)&doc_state->base_state);
+    AMitemToDoc(AMstackItem(&doc_state->base_state->stack, AMcreate(NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_DOC)),
+                &doc_state->doc);
+    *state = doc_state;
+    return 0;
+}
+
+int teardown_doc(void** state) {
+    DocState* doc_state = *state;
+    teardown_base((void**)&doc_state->base_state);
+    test_free(doc_state);
+    return 0;
+}

data/vendor/automerge-rust/automerge-c/test/doc_state.h

@@ -0,0 +1,17 @@
+#ifndef TESTS_DOC_STATE_H
+#define TESTS_DOC_STATE_H
+
+/* local */
+#include <automerge-c/automerge.h>
+#include "base_state.h"
+
+typedef struct {
+    BaseState* base_state;
+    AMdoc* doc;
+} DocState;
+
+int setup_doc(void** state);
+
+int teardown_doc(void** state);
+
+#endif /* TESTS_DOC_STATE_H */

data/vendor/automerge-rust/automerge-c/test/doc_tests.c

@@ -0,0 +1,335 @@
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include <automerge-c/automerge.h>
+#include <automerge-c/config.h>
+#include <automerge-c/utils/stack_callback_data.h>
+#include "base_state.h"
+#include "cmocka_utils.h"
+#include "doc_state.h"
+#include "str_utils.h"
+
+typedef struct {
+    DocState* doc_state;
+    AMbyteSpan actor_id_str;
+    uint8_t* actor_id_bytes;
+    size_t actor_id_size;
+} TestState;
+
+static int setup(void** state) {
+    TestState* test_state = test_calloc(1, sizeof(TestState));
+    setup_doc((void**)&test_state->doc_state);
+    test_state->actor_id_str.src = "000102030405060708090a0b0c0d0e0f";
+    test_state->actor_id_str.count = strlen(test_state->actor_id_str.src);
+    test_state->actor_id_size = test_state->actor_id_str.count / 2;
+    test_state->actor_id_bytes = test_malloc(test_state->actor_id_size);
+    hex_to_bytes(test_state->actor_id_str.src, test_state->actor_id_bytes, test_state->actor_id_size);
+    *state = test_state;
+    return 0;
+}
+
+static int teardown(void** state) {
+    TestState* test_state = *state;
+    teardown_doc((void**)&test_state->doc_state);
+    test_free(test_state->actor_id_bytes);
+    test_free(test_state);
+    return 0;
+}
+
+static void test_AMkeys_empty(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    AMdoc* doc;
+    assert_true(AMitemToDoc(AMstackItem(stack_ptr, AMcreate(NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_DOC)), &doc));
+    AMitems forward = AMstackItems(stack_ptr, AMkeys(doc, AM_ROOT, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    assert_int_equal(AMitemsSize(&forward), 0);
+    AMitems reverse = AMitemsReversed(&forward);
+    assert_int_equal(AMitemsSize(&reverse), 0);
+    assert_null(AMitemsNext(&forward, 1));
+    assert_null(AMitemsPrev(&forward, 1));
+    assert_null(AMitemsNext(&reverse, 1));
+    assert_null(AMitemsPrev(&reverse, 1));
+}
+
+static void test_AMkeys_list(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    AMdoc* doc;
+    assert_true(AMitemToDoc(AMstackItem(stack_ptr, AMcreate(NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_DOC)), &doc));
+    AMobjId const* const list =
+        AMitemObjId(AMstackItem(stack_ptr, AMmapPutObject(doc, AM_ROOT, AMstr("list"), AM_OBJ_TYPE_LIST), cmocka_cb,
+                                AMexpect(AM_VAL_TYPE_OBJ_TYPE)));
+    AMstackItem(NULL, AMlistPutInt(doc, list, 0, true, 0), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMstackItem(NULL, AMlistPutInt(doc, list, 1, true, 0), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMstackItem(NULL, AMlistPutInt(doc, list, 2, true, 0), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMitems forward = AMstackItems(stack_ptr, AMkeys(doc, list, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR));
+    assert_int_equal(AMitemsSize(&forward), 3);
+    AMitems reverse = AMitemsReversed(&forward);
+    assert_int_equal(AMitemsSize(&reverse), 3);
+    /* Forward iterator forward. */
+    AMbyteSpan str;
+    assert_true(AMitemToStr(AMitemsNext(&forward, 1), &str));
+    assert_ptr_equal(strstr(str.src, "2@"), str.src);
+    assert_true(AMitemToStr(AMitemsNext(&forward, 1), &str));
+    assert_ptr_equal(strstr(str.src, "3@"), str.src);
+    assert_true(AMitemToStr(AMitemsNext(&forward, 1), &str));
+    assert_ptr_equal(strstr(str.src, "4@"), str.src);
+    assert_null(AMitemsNext(&forward, 1));
+    // /* Forward iterator reverse. */
+    assert_true(AMitemToStr(AMitemsPrev(&forward, 1), &str));
+    assert_ptr_equal(strstr(str.src, "4@"), str.src);
+    assert_true(AMitemToStr(AMitemsPrev(&forward, 1), &str));
+    assert_ptr_equal(strstr(str.src, "3@"), str.src);
+    assert_true(AMitemToStr(AMitemsPrev(&forward, 1), &str));
+    assert_ptr_equal(strstr(str.src, "2@"), str.src);
+    assert_null(AMitemsPrev(&forward, 1));
+    /* Reverse iterator forward. */
+    assert_true(AMitemToStr(AMitemsNext(&reverse, 1), &str));
+    assert_ptr_equal(strstr(str.src, "4@"), str.src);
+    assert_true(AMitemToStr(AMitemsNext(&reverse, 1), &str));
+    assert_ptr_equal(strstr(str.src, "3@"), str.src);
+    assert_true(AMitemToStr(AMitemsNext(&reverse, 1), &str));
+    assert_ptr_equal(strstr(str.src, "2@"), str.src);
+    assert_null(AMitemsNext(&reverse, 1));
+    /* Reverse iterator reverse. */
+    assert_true(AMitemToStr(AMitemsPrev(&reverse, 1), &str));
+    assert_ptr_equal(strstr(str.src, "2@"), str.src);
+    assert_true(AMitemToStr(AMitemsPrev(&reverse, 1), &str));
+    assert_ptr_equal(strstr(str.src, "3@"), str.src);
+    assert_true(AMitemToStr(AMitemsPrev(&reverse, 1), &str));
+    assert_ptr_equal(strstr(str.src, "4@"), str.src);
+    assert_null(AMitemsPrev(&reverse, 1));
+}
+
+static void test_AMkeys_map(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    AMdoc* doc;
+    assert_true(AMitemToDoc(AMstackItem(stack_ptr, AMcreate(NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_DOC)), &doc));
+    AMstackItem(NULL, AMmapPutInt(doc, AM_ROOT, AMstr("one"), 1), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMstackItem(NULL, AMmapPutInt(doc, AM_ROOT, AMstr("two"), 2), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMstackItem(NULL, AMmapPutInt(doc, AM_ROOT, AMstr("three"), 3), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMitems forward = AMstackItems(stack_ptr, AMkeys(doc, AM_ROOT, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR));
+    assert_int_equal(AMitemsSize(&forward), 3);
+    AMitems reverse = AMitemsReversed(&forward);
+    assert_int_equal(AMitemsSize(&reverse), 3);
+    /* Forward iterator forward. */
+    AMbyteSpan str;
+    assert_true(AMitemToStr(AMitemsNext(&forward, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "one", str.count);
+    assert_true(AMitemToStr(AMitemsNext(&forward, 1), &str));
+    assert_int_equal(str.count, 5);
+    assert_memory_equal(str.src, "three", str.count);
+    assert_true(AMitemToStr(AMitemsNext(&forward, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "two", str.count);
+    assert_null(AMitemsNext(&forward, 1));
+    /* Forward iterator reverse. */
+    assert_true(AMitemToStr(AMitemsPrev(&forward, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "two", str.count);
+    assert_true(AMitemToStr(AMitemsPrev(&forward, 1), &str));
+    assert_int_equal(str.count, 5);
+    assert_memory_equal(str.src, "three", str.count);
+    assert_true(AMitemToStr(AMitemsPrev(&forward, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "one", str.count);
+    assert_null(AMitemsPrev(&forward, 1));
+    /* Reverse iterator forward. */
+    assert_true(AMitemToStr(AMitemsNext(&reverse, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "two", str.count);
+    assert_true(AMitemToStr(AMitemsNext(&reverse, 1), &str));
+    assert_int_equal(str.count, 5);
+    assert_memory_equal(str.src, "three", str.count);
+    assert_true(AMitemToStr(AMitemsNext(&reverse, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "one", str.count);
+    assert_null(AMitemsNext(&reverse, 1));
+    /* Reverse iterator reverse. */
+    assert_true(AMitemToStr(AMitemsPrev(&reverse, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "one", str.count);
+    assert_true(AMitemToStr(AMitemsPrev(&reverse, 1), &str));
+    assert_int_equal(str.count, 5);
+    assert_memory_equal(str.src, "three", str.count);
+    assert_true(AMitemToStr(AMitemsPrev(&reverse, 1), &str));
+    assert_int_equal(str.count, 3);
+    assert_memory_equal(str.src, "two", str.count);
+    assert_null(AMitemsPrev(&reverse, 1));
+}
+
+static void test_AMload(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    FILE* fp = fopen("files/brave-ape-49.automerge", "rb");
+    assert_non_null(fp);
+    fseek(fp, 0L, SEEK_END);
+    size_t const count = ftell(fp);
+    assert_int_not_equal(count, 0);
+    rewind(fp);
+    uint8_t* src = test_calloc(count, sizeof(uint8_t));
+    for (size_t i = 0; i != count; ++i) {
+        src[i] = fgetc(fp);
+    }
+    assert_int_equal(ferror(fp), 0);
+    assert_int_equal(fclose(fp), 0);
+    AMitem* doc_item = AMstackItem(stack_ptr, AMload(src, count), cmocka_cb, AMexpect(AM_VAL_TYPE_DOC));
+    test_free(src);
+    assert_non_null(doc_item);
+    AMdoc* doc = NULL;
+    assert_true(AMitemToDoc(doc_item, &doc));
+    assert_non_null(doc);
+    AMitems keys = AMstackItems(stack_ptr, AMkeys(doc, AM_ROOT, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR));
+
+    enum Key {ASSETS, DATA, DOM, META, SIZE_};
+
+    assert_int_equal(AMitemsSize(&keys), SIZE_);
+    size_t match_counts[SIZE_] = {0};
+    AMitem* key_item;
+    while ((key_item = AMitemsNext(&keys, 1)) != NULL) {
+        AMbyteSpan str;
+        assert_true(AMitemToStr(key_item, &str));
+        if (!strncmp(str.src, "assets", str.count)) {
+            match_counts[ASSETS] += 1;
+        } else if (!strncmp(str.src, "data", str.count)) {
+            match_counts[DATA] += 1;
+        } else if (!strncmp(str.src, "dom", str.count)) {
+            match_counts[DOM] += 1;
+        } else if (!strncmp(str.src, "meta", str.count)) {
+            match_counts[META] += 1;
+        }
+    }
+    assert_int_equal(match_counts[ASSETS], 1);
+    assert_int_equal(match_counts[DATA], 1);
+    assert_int_equal(match_counts[DOM], 1);
+    assert_int_equal(match_counts[META], 1);
+}
+
+static void test_AMputActor_bytes(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    AMactorId const* actor_id;
+    assert_true(AMitemToActorId(
+        AMstackItem(stack_ptr, AMactorIdFromBytes(test_state->actor_id_bytes, test_state->actor_id_size), cmocka_cb,
+                    AMexpect(AM_VAL_TYPE_ACTOR_ID)),
+        &actor_id));
+    AMstackItem(NULL, AMsetActorId(test_state->doc_state->doc, actor_id), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    assert_true(AMitemToActorId(
+        AMstackItem(stack_ptr, AMgetActorId(test_state->doc_state->doc), cmocka_cb, AMexpect(AM_VAL_TYPE_ACTOR_ID)),
+        &actor_id));
+    AMbyteSpan const bytes = AMactorIdBytes(actor_id);
+    assert_int_equal(bytes.count, test_state->actor_id_size);
+    assert_memory_equal(bytes.src, test_state->actor_id_bytes, bytes.count);
+}
+
+static void test_AMputActor_str(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    AMactorId const* actor_id;
+    assert_true(AMitemToActorId(
+        AMstackItem(stack_ptr, AMactorIdFromStr(test_state->actor_id_str), cmocka_cb, AMexpect(AM_VAL_TYPE_ACTOR_ID)),
+        &actor_id));
+    AMstackItem(NULL, AMsetActorId(test_state->doc_state->doc, actor_id), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    assert_true(AMitemToActorId(
+        AMstackItem(stack_ptr, AMgetActorId(test_state->doc_state->doc), cmocka_cb, AMexpect(AM_VAL_TYPE_ACTOR_ID)),
+        &actor_id));
+    AMbyteSpan const str = AMactorIdStr(actor_id);
+    assert_int_equal(str.count, test_state->actor_id_str.count);
+    assert_memory_equal(str.src, test_state->actor_id_str.src, str.count);
+}
+
+#define assert_str_equal(actual, expected) \
+    assert_int_equal(actual.count, strlen(expected)); \
+    assert_memory_equal(actual.src, expected, actual.count);
+
+static void test_AMspliceText(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->doc_state->base_state->stack;
+    AMdoc* doc;
+    assert_true(AMitemToDoc(AMstackItem(stack_ptr, AMcreate(NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_DOC)), &doc));
+    AMobjId const* const text =
+        AMitemObjId(AMstackItem(stack_ptr, AMmapPutObject(doc, AM_ROOT, AMstr("text"), AM_OBJ_TYPE_TEXT), cmocka_cb,
+                                AMexpect(AM_VAL_TYPE_OBJ_TYPE)));
+    AMstackItem(NULL, AMspliceText(doc, text, 0, 0, AMstr("one + ")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMstackItem(NULL, AMspliceText(doc, text, 4, 2, AMstr("two = ")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMstackItem(NULL, AMspliceText(doc, text, 8, 2, AMstr("three")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    AMbyteSpan str;
+    assert_true(
+        AMitemToStr(AMstackItem(stack_ptr, AMtext(doc, text, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR)), &str));
+    assert_int_equal(str.count, strlen("one two three"));
+    assert_memory_equal(str.src, "one two three", str.count);
+
+    AMobjId const* const unicode =
+        AMitemObjId(AMstackItem(stack_ptr, AMmapPutObject(doc, AM_ROOT, AMstr("unicode"), AM_OBJ_TYPE_TEXT), cmocka_cb,
+                                AMexpect(AM_VAL_TYPE_OBJ_TYPE)));
+    AMstackItem(NULL, AMspliceText(doc, unicode, 0, 0, AMstr("🇬🇧🇩🇪")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+
+#if defined(AUTOMERGE_C_UTF8)
+
+    AMstackItem(NULL, AMspliceText(doc, unicode, 8, 4, AMstr("🇦")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+
+    assert_int_equal(AMobjSize(doc, unicode, NULL), 16);
+
+    assert_true(
+        AMitemToStr(AMstackItem(stack_ptr, AMtext(doc, unicode, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR)), &str));
+    assert_str_equal(str, "🇬🇧🇦🇪");
+
+    AMobjId const* const edge =
+        AMitemObjId(AMstackItem(stack_ptr, AMmapPutObject(doc, AM_ROOT, AMstr("edge"), AM_OBJ_TYPE_TEXT), cmocka_cb,
+                                AMexpect(AM_VAL_TYPE_OBJ_TYPE)));
+    AMstackItem(NULL, AMspliceText(doc, edge, 0, 0, AMstr("🇬🇧")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+    // it should delete the whole character instead of partial characters
+    AMstackItem(NULL, AMspliceText(doc, edge, 4, 1, AMstr("")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+
+    assert_true(
+        AMitemToStr(AMstackItem(stack_ptr, AMtext(doc, edge, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR)), &str));
+    assert_str_equal(str, "🇬");
+
+    // it should insert at the character boundary
+    AMstackItem(NULL, AMspliceText(doc, edge, 2, 0, AMstr("🇵")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+
+    assert_true(
+        AMitemToStr(AMstackItem(stack_ptr, AMtext(doc, edge, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR)), &str));
+    assert_str_equal(str, "🇬🇵");
+
+#elif defined(AUTOMERGE_C_UTF32)
+
+    AMstackItem(NULL, AMspliceText(doc, unicode, 2, 1, AMstr("🇦")), cmocka_cb, AMexpect(AM_VAL_TYPE_VOID));
+
+    assert_int_equal(AMobjSize(doc, unicode, NULL), 4);
+
+    assert_true(
+        AMitemToStr(AMstackItem(stack_ptr, AMtext(doc, unicode, NULL), cmocka_cb, AMexpect(AM_VAL_TYPE_STR)), &str));
+    assert_str_equal(str, "🇬🇧🇦🇪");
+
+#else
+
+    print_error("%s", "Neither `AUTOMERGE_C_UTF8` nor `AUTOMERGE_C_UTF32` are defined.");
+
+#endif
+}
+
+int run_doc_tests(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test_setup_teardown(test_AMkeys_empty, setup, teardown),
+        cmocka_unit_test_setup_teardown(test_AMkeys_list, setup, teardown),
+        cmocka_unit_test_setup_teardown(test_AMkeys_map, setup, teardown),
+        cmocka_unit_test_setup_teardown(test_AMload, setup, teardown),
+        cmocka_unit_test_setup_teardown(test_AMputActor_bytes, setup, teardown),
+        cmocka_unit_test_setup_teardown(test_AMputActor_str, setup, teardown),
+        cmocka_unit_test_setup_teardown(test_AMspliceText, setup, teardown),
+    };
+
+    return cmocka_run_group_tests(tests, NULL, NULL);
+}