automerge-rb 0.1.1

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

@@ -0,0 +1,140 @@
+#include <math.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include <automerge-c/automerge.h>
+#include "cmocka_utils.h"
+#include "str_utils.h"
+
+/**
+ * \brief State for a group of cmocka test cases.
+ */
+typedef struct {
+    /** An actor ID as an array of bytes. */
+    uint8_t* src;
+    /** The count of bytes in \p src. */
+    size_t count;
+    /** A stack of results. */
+    AMstack* stack;
+    /** An actor ID as a hexadecimal string. */
+    AMbyteSpan str;
+} TestState;
+
+static int setup(void** state) {
+    TestState* test_state = test_calloc(1, sizeof(TestState));
+    test_state->str = AMstr("000102030405060708090a0b0c0d0e0f");
+    test_state->count = test_state->str.count / 2;
+    test_state->src = test_calloc(test_state->count, sizeof(uint8_t));
+    hex_to_bytes(test_state->str.src, test_state->src, test_state->count);
+    *state = test_state;
+    return 0;
+}
+
+static int teardown(void** state) {
+    TestState* test_state = *state;
+    test_free(test_state->src);
+    AMstackFree(&test_state->stack);
+    test_free(test_state);
+    return 0;
+}
+
+static void test_AMactorIdFromBytes(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->stack;
+    /* Non-empty string. */
+    AMresult* result = AMstackResult(stack_ptr, AMactorIdFromBytes(test_state->src, test_state->count), NULL, NULL);
+    if (AMresultStatus(result) != AM_STATUS_OK) {
+        fail_msg_view("%s", AMresultError(result));
+    }
+    assert_int_equal(AMresultSize(result), 1);
+    AMitem* const item = AMresultItem(result);
+    assert_int_equal(AMitemValType(item), AM_VAL_TYPE_ACTOR_ID);
+    AMactorId const* actor_id;
+    assert_true(AMitemToActorId(item, &actor_id));
+    AMbyteSpan const bytes = AMactorIdBytes(actor_id);
+    assert_int_equal(bytes.count, test_state->count);
+    assert_memory_equal(bytes.src, test_state->src, bytes.count);
+    /* Empty array. */
+    /** \todo Find out if this is intentionally allowed. */
+    result = AMstackResult(stack_ptr, AMactorIdFromBytes(test_state->src, 0), NULL, NULL);
+    if (AMresultStatus(result) != AM_STATUS_OK) {
+        fail_msg_view("%s", AMresultError(result));
+    }
+    /* NULL array. */
+    result = AMstackResult(stack_ptr, AMactorIdFromBytes(NULL, test_state->count), NULL, NULL);
+    if (AMresultStatus(result) == AM_STATUS_OK) {
+        fail_msg("`AMactorId` from `NULL`.");
+    }
+}
+
+static void test_AMactorIdFromStr(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->stack;
+    AMresult* result = AMstackResult(stack_ptr, AMactorIdFromStr(test_state->str), NULL, NULL);
+    if (AMresultStatus(result) != AM_STATUS_OK) {
+        fail_msg_view("%s", AMresultError(result));
+    }
+    assert_int_equal(AMresultSize(result), 1);
+    AMitem* const item = AMresultItem(result);
+    assert_int_equal(AMitemValType(item), AM_VAL_TYPE_ACTOR_ID);
+    /* The hexadecimal string should've been decoded as identical bytes. */
+    AMactorId const* actor_id;
+    assert_true(AMitemToActorId(item, &actor_id));
+    AMbyteSpan const bytes = AMactorIdBytes(actor_id);
+    assert_int_equal(bytes.count, test_state->count);
+    assert_memory_equal(bytes.src, test_state->src, bytes.count);
+    /* The bytes should've been encoded as an identical hexadecimal string. */
+    assert_true(AMitemToActorId(item, &actor_id));
+    AMbyteSpan const str = AMactorIdStr(actor_id);
+    assert_int_equal(str.count, test_state->str.count);
+    assert_memory_equal(str.src, test_state->str.src, str.count);
+}
+
+static void test_AMactorIdInit(void** state) {
+    TestState* test_state = *state;
+    AMstack** stack_ptr = &test_state->stack;
+    AMresult* prior_result = NULL;
+    AMbyteSpan prior_bytes = {NULL, 0};
+    AMbyteSpan prior_str = {NULL, 0};
+    for (size_t i = 0; i != 11; ++i) {
+        AMresult* result = AMstackResult(stack_ptr, AMactorIdInit(), NULL, NULL);
+        if (AMresultStatus(result) != AM_STATUS_OK) {
+            fail_msg_view("%s", AMresultError(result));
+        }
+        assert_int_equal(AMresultSize(result), 1);
+        AMitem* const item = AMresultItem(result);
+        assert_int_equal(AMitemValType(item), AM_VAL_TYPE_ACTOR_ID);
+        AMactorId const* actor_id;
+        assert_true(AMitemToActorId(item, &actor_id));
+        AMbyteSpan const bytes = AMactorIdBytes(actor_id);
+        assert_true(AMitemToActorId(item, &actor_id));
+        AMbyteSpan const str = AMactorIdStr(actor_id);
+        if (prior_result) {
+            size_t const max_byte_count = fmax(bytes.count, prior_bytes.count);
+            assert_memory_not_equal(bytes.src, prior_bytes.src, max_byte_count);
+            size_t const max_char_count = fmax(str.count, prior_str.count);
+            assert_memory_not_equal(str.src, prior_str.src, max_char_count);
+        }
+        prior_result = result;
+        prior_bytes = bytes;
+        prior_str = str;
+    }
+}
+
+int run_actor_id_tests(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_AMactorIdFromBytes),
+        cmocka_unit_test(test_AMactorIdFromStr),
+        cmocka_unit_test(test_AMactorIdInit),
+    };
+
+    return cmocka_run_group_tests(tests, setup, teardown);
+}

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

@@ -0,0 +1,17 @@
+#include <stdlib.h>
+
+/* local */
+#include "base_state.h"
+
+int setup_base(void** state) {
+    BaseState* base_state = calloc(1, sizeof(BaseState));
+    *state = base_state;
+    return 0;
+}
+
+int teardown_base(void** state) {
+    BaseState* base_state = *state;
+    AMstackFree(&base_state->stack);
+    free(base_state);
+    return 0;
+}

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

@@ -0,0 +1,39 @@
+#ifndef TESTS_BASE_STATE_H
+#define TESTS_BASE_STATE_H
+
+#include <stdint.h>
+
+/* local */
+#include <automerge-c/automerge.h>
+#include <automerge-c/utils/stack.h>
+
+/**
+ * \struct BaseState
+ * \brief The shared state for one or more cmocka test cases.
+ */
+typedef struct {
+    /** A stack of results. */
+    AMstack* stack;
+} BaseState;
+
+/**
+ * \memberof BaseState
+ * \brief Sets up the shared state for one or more cmocka test cases.
+ *
+ * \param[in,out] state A pointer to a pointer to a `BaseState` struct.
+ * \pre \p state `!= NULL`.
+ * \warning The `BaseState` struct returned through \p state must be
+ *          passed to `teardown_base()` in order to avoid a memory leak.
+ */
+int setup_base(void** state);
+
+/**
+ * \memberof BaseState
+ * \brief Tears down the shared state for one or more cmocka test cases.
+ *
+ * \param[in] state A pointer to a pointer to a `BaseState` struct.
+ * \pre \p state `!= NULL`.
+ */
+int teardown_base(void** state);
+
+#endif /* TESTS_BASE_STATE_H */

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

@@ -0,0 +1,119 @@
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* third-party */
+#include <cmocka.h>
+
+/* local */
+#include <automerge-c/automerge.h>
+#include <automerge-c/utils/string.h>
+
+static void test_AMbytes(void** state) {
+    static char const DATA[] = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
+
+    AMbyteSpan bytes = AMbytes(DATA, sizeof(DATA));
+    assert_int_equal(bytes.count, sizeof(DATA));
+    assert_memory_equal(bytes.src, DATA, bytes.count);
+    assert_ptr_equal(bytes.src, DATA);
+    /* Empty view */
+    bytes = AMbytes(DATA, 0);
+    assert_int_equal(bytes.count, 0);
+    assert_ptr_equal(bytes.src, DATA);
+    /* Invalid array */
+    bytes = AMbytes(NULL, SIZE_MAX);
+    assert_int_not_equal(bytes.count, SIZE_MAX);
+    assert_int_equal(bytes.count, 0);
+    assert_ptr_equal(bytes.src, NULL);
+}
+
+static void test_AMstr(void** state) {
+    AMbyteSpan str = AMstr("abcdefghijkl");
+    assert_int_equal(str.count, strlen("abcdefghijkl"));
+    assert_memory_equal(str.src, "abcdefghijkl", str.count);
+    /* Empty string */
+    static char const* const EMPTY = "";
+
+    str = AMstr(EMPTY);
+    assert_int_equal(str.count, 0);
+    assert_ptr_equal(str.src, EMPTY);
+    /* Invalid string */
+    str = AMstr(NULL);
+    assert_int_equal(str.count, 0);
+    assert_ptr_equal(str.src, NULL);
+}
+
+static void test_AMstrCmp(void** state) {
+    /* Length ordering */
+    assert_int_equal(AMstrCmp(AMstr("abcdef"), AMstr("abcdefghijkl")), -1);
+    assert_int_equal(AMstrCmp(AMstr("abcdefghijkl"), AMstr("abcdefghijkl")), 0);
+    assert_int_equal(AMstrCmp(AMstr("abcdefghijkl"), AMstr("abcdef")), 1);
+    /* Lexicographical ordering */
+    assert_int_equal(AMstrCmp(AMstr("abcdef"), AMstr("ghijkl")), -1);
+    assert_int_equal(AMstrCmp(AMstr("ghijkl"), AMstr("abcdef")), 1);
+    /* Case ordering */
+    assert_int_equal(AMstrCmp(AMstr("ABCDEFGHIJKL"), AMstr("abcdefghijkl")), -1);
+    assert_int_equal(AMstrCmp(AMstr("ABCDEFGHIJKL"), AMstr("ABCDEFGHIJKL")), 0);
+    assert_int_equal(AMstrCmp(AMstr("abcdefghijkl"), AMstr("ABCDEFGHIJKL")), 1);
+    assert_int_equal(AMstrCmp(AMstr("ABCDEFGHIJKL"), AMstr("abcdef")), -1);
+    assert_int_equal(AMstrCmp(AMstr("abcdef"), AMstr("ABCDEFGHIJKL")), 1);
+    assert_int_equal(AMstrCmp(AMstr("GHIJKL"), AMstr("abcdef")), -1);
+    assert_int_equal(AMstrCmp(AMstr("abcdef"), AMstr("GHIJKL")), 1);
+    /* NUL character inclusion */
+    static char const SRC[] = {'a', 'b', 'c', 'd', 'e', 'f', '\0', 'g', 'h', 'i', 'j', 'k', 'l'};
+    static AMbyteSpan const NUL_STR = {.src = SRC, .count = 13};
+
+    assert_int_equal(AMstrCmp(AMstr("abcdef"), NUL_STR), -1);
+    assert_int_equal(AMstrCmp(NUL_STR, NUL_STR), 0);
+    assert_int_equal(AMstrCmp(NUL_STR, AMstr("abcdef")), 1);
+    /* Empty string */
+    assert_int_equal(AMstrCmp(AMstr(""), AMstr("abcdefghijkl")), -1);
+    assert_int_equal(AMstrCmp(AMstr(""), AMstr("")), 0);
+    assert_int_equal(AMstrCmp(AMstr("abcdefghijkl"), AMstr("")), 1);
+    /* Invalid string */
+    assert_int_equal(AMstrCmp(AMstr(NULL), AMstr("abcdefghijkl")), -1);
+    assert_int_equal(AMstrCmp(AMstr(NULL), AMstr(NULL)), 0);
+    assert_int_equal(AMstrCmp(AMstr("abcdefghijkl"), AMstr(NULL)), 1);
+}
+
+static void test_AMstrdup(void** state) {
+    static char const SRC[] = {'a', 'b', 'c', '\0', 'd', 'e', 'f', '\0', 'g', 'h', 'i', '\0', 'j', 'k', 'l'};
+    static AMbyteSpan const NUL_STR = {.src = SRC, .count = 15};
+
+    /* Default substitution ("\\0") for NUL */
+    char* dup = AMstrdup(NUL_STR, NULL);
+    assert_int_equal(strlen(dup), 18);
+    assert_string_equal(dup, "abc\\0def\\0ghi\\0jkl");
+    free(dup);
+    /* Arbitrary substitution for NUL */
+    dup = AMstrdup(NUL_STR, ":-O");
+    assert_int_equal(strlen(dup), 21);
+    assert_string_equal(dup, "abc:-Odef:-Oghi:-Ojkl");
+    free(dup);
+    /* Empty substitution for NUL */
+    dup = AMstrdup(NUL_STR, "");
+    assert_int_equal(strlen(dup), 12);
+    assert_string_equal(dup, "abcdefghijkl");
+    free(dup);
+    /* Empty string */
+    dup = AMstrdup(AMstr(""), NULL);
+    assert_int_equal(strlen(dup), 0);
+    assert_string_equal(dup, "");
+    free(dup);
+    /* Invalid string */
+    assert_null(AMstrdup(AMstr(NULL), NULL));
+}
+
+int run_byte_span_tests(void) {
+    const struct CMUnitTest tests[] = {
+        cmocka_unit_test(test_AMbytes),
+        cmocka_unit_test(test_AMstr),
+        cmocka_unit_test(test_AMstrCmp),
+        cmocka_unit_test(test_AMstrdup),
+    };
+
+    return cmocka_run_group_tests(tests, NULL, NULL);
+}

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

@@ -0,0 +1,91 @@
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+/* third-party */
+#include <automerge-c/utils/enum_string.h>
+#include <automerge-c/utils/stack_callback_data.h>
+#include <automerge-c/utils/string.h>
+#include <cmocka.h>
+
+/* local */
+#include "cmocka_utils.h"
+
+/**
+ * \brief Assert that the given expression is true and report failure in terms
+ *        of a line number within a file.
+ *
+ * \param[in] c An expression.
+ * \param[in] file A file's full path string.
+ * \param[in] line A line number.
+ */
+#define assert_true_where(c, file, line) _assert_true(cast_ptr_to_largest_integral_type(c), #c, file, line)
+
+/**
+ * \brief Assert that the given pointer is non-NULL and report failure in terms
+ *        of a line number within a file.
+ *
+ * \param[in] c An expression.
+ * \param[in] file A file's full path string.
+ * \param[in] line A line number.
+ */
+#define assert_non_null_where(c, file, line) assert_true_where(c, file, line)
+
+/**
+ * \brief Forces the test to fail immediately and quit, printing the reason in
+ *        terms of a line number within a file.
+ *
+ * \param[in] msg A message string into which \p str is interpolated.
+ * \param[in] str An owned string.
+ * \param[in] file A file's full path string.
+ * \param[in] line A line number.
+ */
+#define fail_msg_where(msg, str, file, line)  \
+    do {                                      \
+        print_error("ERROR: " msg "\n", str); \
+        _fail(file, line);                    \
+    } while (0)
+
+/**
+ * \brief Forces the test to fail immediately and quit, printing the reason in
+ *        terms of a line number within a file.
+ *
+ * \param[in] msg A message string into which \p view.src is interpolated.
+ * \param[in] view A UTF-8 string view as an `AMbyteSpan` struct.
+ * \param[in] file A file's full path string.
+ * \param[in] line A line number.
+ */
+#define fail_msg_view_where(msg, view, file, line) \
+    do {                                           \
+        char* const str = AMstrdup(view, NULL);    \
+        print_error("ERROR: " msg "\n", str);      \
+        free(str);                                 \
+        _fail(file, line);                         \
+    } while (0)
+
+bool cmocka_cb(AMstack** stack, void* data) {
+    assert_non_null(data);
+    AMstackCallbackData* const sc_data = (AMstackCallbackData*)data;
+    assert_non_null_where(stack, sc_data->file, sc_data->line);
+    assert_non_null_where(*stack, sc_data->file, sc_data->line);
+    assert_non_null_where((*stack)->result, sc_data->file, sc_data->line);
+    if (AMresultStatus((*stack)->result) != AM_STATUS_OK) {
+        fail_msg_view_where("%s", AMresultError((*stack)->result), sc_data->file, sc_data->line);
+        free(data);
+        return false;
+    }
+    /* Test that the types of all item values are members of the mask. */
+    AMitems items = AMresultItems((*stack)->result);
+    AMitem* item = NULL;
+    while ((item = AMitemsNext(&items, 1)) != NULL) {
+        AMvalType const tag = AMitemValType(item);
+        if (!(tag & sc_data->bitmask)) {
+            fail_msg_where("Unexpected value type `%s`.", AMvalTypeToString(tag), sc_data->file, sc_data->line);
+            free(data);
+            return false;
+        }
+    }
+    free(data);
+    return true;
+}

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

@@ -0,0 +1,42 @@
+#ifndef TESTS_CMOCKA_UTILS_H
+#define TESTS_CMOCKA_UTILS_H
+
+#include <stdlib.h>
+#include <string.h>
+
+/* third-party */
+#include <automerge-c/utils/string.h>
+#include <cmocka.h>
+
+/* local */
+#include "base_state.h"
+
+/**
+ * \brief Forces the test to fail immediately and quit, printing the reason.
+ *
+ * \param[in] msg A message string into which \p view.src is interpolated.
+ * \param[in] view A UTF-8 string view as an `AMbyteSpan` struct.
+ */
+#define fail_msg_view(msg, view)                  \
+    do {                                          \
+        char* const c_str = AMstrdup(view, NULL); \
+        print_error("ERROR: " msg "\n", c_str);   \
+        free(c_str);                              \
+        fail();                                   \
+    } while (0)
+
+/**
+ * \brief Validates the top result in a stack based upon the parameters
+ *        specified within the given data structure and reports violations
+ *        using cmocka assertions.
+ *
+ * \param[in,out] stack A pointer to a pointer to an `AMstack` struct.
+ * \param[in] data A pointer to an owned `AMpushData` struct.
+ * \return `true` if the top `AMresult` struct in \p stack is valid, `false`
+ *         otherwise.
+ * \pre \p stack `!= NULL`.
+ * \pre \p data `!= NULL`.
+ */
+bool cmocka_cb(AMstack** stack, void* data);
+
+#endif /* TESTS_CMOCKA_UTILS_H */