automerge-rb 0.1.1

data/vendor/automerge-rust/automerge-c/src/sync/message.rs

@@ -0,0 +1,146 @@
+use automerge as am;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+
+use crate::change::AMchange;
+use crate::result::{to_result, AMresult};
+use crate::sync::have::AMsyncHave;
+
+macro_rules! to_sync_message {
+    ($handle:expr) => {{
+        let handle = $handle.as_ref();
+        match handle {
+            Some(b) => b,
+            None => return AMresult::error("Invalid `AMsyncMessage*`").into(),
+        }
+    }};
+}
+
+pub(crate) use to_sync_message;
+
+/// \struct AMsyncMessage
+/// \installed_headerfile
+/// \brief A synchronization message for a peer.
+#[derive(PartialEq)]
+pub struct AMsyncMessage {
+    body: am::sync::Message,
+    changes_storage: RefCell<BTreeMap<usize, AMchange>>,
+    haves_storage: RefCell<BTreeMap<usize, AMsyncHave>>,
+}
+
+impl AMsyncMessage {
+    pub fn new(message: am::sync::Message) -> Self {
+        Self {
+            body: message,
+            changes_storage: RefCell::new(BTreeMap::new()),
+            haves_storage: RefCell::new(BTreeMap::new()),
+        }
+    }
+}
+
+impl AsRef<am::sync::Message> for AMsyncMessage {
+    fn as_ref(&self) -> &am::sync::Message {
+        &self.body
+    }
+}
+
+/// \memberof AMsyncMessage
+/// \brief Decodes an array of bytes into a synchronization message.
+///
+/// \param[in] src A pointer to an array of bytes.
+/// \param[in] count The count of bytes to decode from the array pointed to by
+///                  \p src.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_SYNC_MESSAGE` item.
+/// \pre \p src `!= NULL`
+/// \pre `sizeof(`\p src `) > 0`
+/// \pre \p count `<= sizeof(`\p src `)`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// src must be a byte array of length `>= count`
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncMessageDecode(src: *const u8, count: usize) -> *mut AMresult {
+    let data = std::slice::from_raw_parts(src, count);
+    to_result(am::sync::Message::decode(data))
+}
+
+/// \memberof AMsyncMessage
+/// \brief Encodes a synchronization message as an array of bytes.
+///
+/// \param[in] sync_message A pointer to an `AMsyncMessage` struct.
+/// \return A pointer to an `AMresult` struct with an `AM_VAL_TYPE_BYTES` item.
+/// \pre \p sync_message `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_message must be a valid pointer to an AMsyncMessage
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncMessageEncode(sync_message: *const AMsyncMessage) -> *mut AMresult {
+    let sync_message = to_sync_message!(sync_message);
+    to_result(sync_message.as_ref().clone().encode())
+}
+
+/// \memberof AMsyncMessage
+/// \brief Gets a summary of the changes that the sender already has.
+///
+/// \param[in] sync_message A pointer to an `AMsyncMessage` struct.
+/// \return A pointer to an `AMresult` struct with `AM_SYNC_HAVE` items.
+/// \pre \p sync_message `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_message must be a valid pointer to an AMsyncMessage
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncMessageHaves(sync_message: *const AMsyncMessage) -> *mut AMresult {
+    to_result(match sync_message.as_ref() {
+        Some(sync_message) => sync_message.as_ref().have.as_slice(),
+        None => Default::default(),
+    })
+}
+
+/// \memberof AMsyncMessage
+/// \brief Gets the heads of the sender.
+///
+/// \param[in] sync_message A pointer to an `AMsyncMessage` struct.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_CHANGE_HASH` items.
+/// \pre \p sync_message `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_message must be a valid pointer to an AMsyncMessage
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncMessageHeads(sync_message: *const AMsyncMessage) -> *mut AMresult {
+    to_result(match sync_message.as_ref() {
+        Some(sync_message) => sync_message.as_ref().heads.as_slice(),
+        None => Default::default(),
+    })
+}
+
+/// \memberof AMsyncMessage
+/// \brief Gets the hashes of any changes that are being explicitly requested
+///        by the recipient.
+///
+/// \param[in] sync_message A pointer to an `AMsyncMessage` struct.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_CHANGE_HASH` items.
+/// \pre \p sync_message `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_message must be a valid pointer to an AMsyncMessage
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncMessageNeeds(sync_message: *const AMsyncMessage) -> *mut AMresult {
+    to_result(match sync_message.as_ref() {
+        Some(sync_message) => sync_message.as_ref().need.as_slice(),
+        None => Default::default(),
+    })
+}

data/vendor/automerge-rust/automerge-c/src/sync/state.rs

@@ -0,0 +1,262 @@
+use automerge as am;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+
+use crate::result::{to_result, AMresult};
+use crate::sync::have::AMsyncHave;
+
+macro_rules! to_sync_state {
+    ($handle:expr) => {{
+        let handle = $handle.as_ref();
+        match handle {
+            Some(b) => b,
+            None => return AMresult::error("Invalid `AMsyncState*`").into(),
+        }
+    }};
+}
+
+pub(crate) use to_sync_state;
+
+/// \struct AMsyncState
+/// \installed_headerfile
+/// \brief The state of synchronization with a peer.
+#[derive(Eq, PartialEq)]
+pub struct AMsyncState {
+    body: am::sync::State,
+    their_haves_storage: RefCell<BTreeMap<usize, AMsyncHave>>,
+}
+
+impl AMsyncState {
+    pub fn new(state: am::sync::State) -> Self {
+        Self {
+            body: state,
+            their_haves_storage: RefCell::new(BTreeMap::new()),
+        }
+    }
+}
+
+impl AsMut<am::sync::State> for AMsyncState {
+    fn as_mut(&mut self) -> &mut am::sync::State {
+        &mut self.body
+    }
+}
+
+impl AsRef<am::sync::State> for AMsyncState {
+    fn as_ref(&self) -> &am::sync::State {
+        &self.body
+    }
+}
+
+impl From<AMsyncState> for *mut AMsyncState {
+    fn from(b: AMsyncState) -> Self {
+        Box::into_raw(Box::new(b))
+    }
+}
+
+/// \memberof AMsyncState
+/// \brief Decodes an array of bytes into a synchronization state.
+///
+/// \param[in] src A pointer to an array of bytes.
+/// \param[in] count The count of bytes to decode from the array pointed to by
+///                  \p src.
+/// \return A pointer to an `AMresult` struct with an `AM_VAL_TYPE_SYNC_STATE` item.
+/// \pre \p src `!= NULL`
+/// \pre `sizeof(`\p src `) > 0`
+/// \pre \p count `<= sizeof(`\p src `)`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// src must be a byte array of length `>= count`
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateDecode(src: *const u8, count: usize) -> *mut AMresult {
+    let data = std::slice::from_raw_parts(src, count);
+    to_result(am::sync::State::decode(data))
+}
+
+/// \memberof AMsyncState
+/// \brief Encodes a synchronization state as an array of bytes.
+///
+/// \param[in] sync_state A pointer to an `AMsyncState` struct.
+/// \return A pointer to an `AMresult` struct with an `AM_VAL_TYPE_BYTE_SPAN` item.
+/// \pre \p sync_state `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_state must be a valid pointer to an AMsyncState
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateEncode(sync_state: *const AMsyncState) -> *mut AMresult {
+    let sync_state = to_sync_state!(sync_state);
+    to_result(sync_state.as_ref().encode())
+}
+
+/// \memberof AMsyncState
+/// \brief Tests the equality of two synchronization states.
+///
+/// \param[in] sync_state1 A pointer to an `AMsyncState` struct.
+/// \param[in] sync_state2 A pointer to an `AMsyncState` struct.
+/// \return `true` if \p sync_state1 `==` \p sync_state2 and `false` otherwise.
+/// \pre \p sync_state1 `!= NULL`
+/// \pre \p sync_state2 `!= NULL`
+/// \post `!(`\p sync_state1 `&&` \p sync_state2 `) -> false`
+/// \internal
+///
+/// #Safety
+/// sync_state1 must be a valid pointer to an AMsyncState
+/// sync_state2 must be a valid pointer to an AMsyncState
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateEqual(
+    sync_state1: *const AMsyncState,
+    sync_state2: *const AMsyncState,
+) -> bool {
+    match (sync_state1.as_ref(), sync_state2.as_ref()) {
+        (Some(sync_state1), Some(sync_state2)) => sync_state1.as_ref() == sync_state2.as_ref(),
+        (None, None) | (None, Some(_)) | (Some(_), None) => false,
+    }
+}
+
+/// \memberof AMsyncState
+/// \brief Allocates a new synchronization state and initializes it from
+///        default values.
+///
+/// \return A pointer to an `AMresult` struct with an `AM_VAL_TYPE_SYNC_STATE` item.
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+#[no_mangle]
+pub extern "C" fn AMsyncStateInit() -> *mut AMresult {
+    to_result(am::sync::State::new())
+}
+
+/// \memberof AMsyncState
+/// \brief Gets the heads that are shared by both peers.
+///
+/// \param[in] sync_state A pointer to an `AMsyncState` struct.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_CHANGE_HASH` items.
+/// \pre \p sync_state `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_state must be a valid pointer to an AMsyncState
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateSharedHeads(sync_state: *const AMsyncState) -> *mut AMresult {
+    let sync_state = to_sync_state!(sync_state);
+    to_result(sync_state.as_ref().shared_heads.as_slice())
+}
+
+/// \memberof AMsyncState
+/// \brief Gets the heads that were last sent by this peer.
+///
+/// \param[in] sync_state A pointer to an `AMsyncState` struct.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_CHANGE_HASH` items.
+/// \pre \p sync_state `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_state must be a valid pointer to an AMsyncState
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateLastSentHeads(sync_state: *const AMsyncState) -> *mut AMresult {
+    let sync_state = to_sync_state!(sync_state);
+    to_result(sync_state.as_ref().last_sent_heads.as_slice())
+}
+
+/// \memberof AMsyncState
+/// \brief Gets a summary of the changes that the other peer already has.
+///
+/// \param[in] sync_state A pointer to an `AMsyncState` struct.
+/// \param[out] has_value A pointer to a boolean flag that is set to `true` if
+///             the returned `AMitems` struct is relevant, `false` otherwise.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_SYNC_HAVE` items.
+/// \pre \p sync_state `!= NULL`
+/// \pre \p has_value `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_state must be a valid pointer to an AMsyncState
+/// has_value must be a valid pointer to a bool.
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateTheirHaves(
+    sync_state: *const AMsyncState,
+    has_value: *mut bool,
+) -> *mut AMresult {
+    if let Some(sync_state) = sync_state.as_ref() {
+        if let Some(haves) = &sync_state.as_ref().their_have {
+            *has_value = true;
+            return to_result(haves.as_slice());
+        }
+    };
+    *has_value = false;
+    to_result(Vec::<am::sync::Have>::new())
+}
+
+/// \memberof AMsyncState
+/// \brief Gets the heads that were sent by the other peer.
+///
+/// \param[in] sync_state A pointer to an `AMsyncState` struct.
+/// \param[out] has_value A pointer to a boolean flag that is set to `true` if
+///                       the returned `AMitems` struct is relevant, `false`
+///                       otherwise.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_CHANGE_HASH` items.
+/// \pre \p sync_state `!= NULL`
+/// \pre \p has_value `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_state must be a valid pointer to an AMsyncState
+/// has_value must be a valid pointer to a bool
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateTheirHeads(
+    sync_state: *const AMsyncState,
+    has_value: *mut bool,
+) -> *mut AMresult {
+    if let Some(sync_state) = sync_state.as_ref() {
+        if let Some(change_hashes) = &sync_state.as_ref().their_heads {
+            *has_value = true;
+            return to_result(change_hashes.as_slice());
+        }
+    };
+    *has_value = false;
+    to_result(Vec::<am::ChangeHash>::new())
+}
+
+/// \memberof AMsyncState
+/// \brief Gets the needs that were sent by the other peer.
+///
+/// \param[in] sync_state A pointer to an `AMsyncState` struct.
+/// \param[out] has_value A pointer to a boolean flag that is set to `true` if
+///                       the returned `AMitems` struct is relevant, `false`
+///                       otherwise.
+/// \return A pointer to an `AMresult` struct with `AM_VAL_TYPE_CHANGE_HASH` items.
+/// \pre \p sync_state `!= NULL`
+/// \pre \p has_value `!= NULL`
+/// \warning The returned `AMresult` struct pointer must be passed to
+///          `AMresultFree()` in order to avoid a memory leak.
+/// \internal
+///
+/// # Safety
+/// sync_state must be a valid pointer to an AMsyncState
+/// has_value must be a valid pointer to a bool
+#[no_mangle]
+pub unsafe extern "C" fn AMsyncStateTheirNeeds(
+    sync_state: *const AMsyncState,
+    has_value: *mut bool,
+) -> *mut AMresult {
+    if let Some(sync_state) = sync_state.as_ref() {
+        if let Some(change_hashes) = &sync_state.as_ref().their_need {
+            *has_value = true;
+            return to_result(change_hashes.as_slice());
+        }
+    };
+    *has_value = false;
+    to_result(Vec::<am::ChangeHash>::new())
+}

data/vendor/automerge-rust/automerge-c/src/sync.rs

@@ -0,0 +1,7 @@
+mod have;
+mod message;
+mod state;
+
+pub(crate) use have::AMsyncHave;
+pub(crate) use message::{to_sync_message, AMsyncMessage};
+pub(crate) use state::AMsyncState;

data/vendor/automerge-rust/automerge-c/src/utils/result.c

@@ -0,0 +1,33 @@
+#include <stdarg.h>
+
+#include <automerge-c/utils/result.h>
+
+AMresult* AMresultFrom(int count, ...) {
+    AMresult* result = NULL;
+    bool is_ok = true;
+    va_list args;
+    va_start(args, count);
+    for (int i = 0; i != count; ++i) {
+        AMresult* src = va_arg(args, AMresult*);
+        AMresult* dest = result;
+        is_ok = (AMresultStatus(src) == AM_STATUS_OK);
+        if (is_ok) {
+            if (dest) {
+                result = AMresultCat(dest, src);
+                is_ok = (AMresultStatus(result) == AM_STATUS_OK);
+                AMresultFree(dest);
+                AMresultFree(src);
+            } else {
+                result = src;
+            }
+        } else {
+            AMresultFree(src);
+        }
+    }
+    va_end(args);
+    if (!is_ok) {
+        AMresultFree(result);
+        result = NULL;
+    }
+    return result;
+}

data/vendor/automerge-rust/automerge-c/src/utils/stack.c

@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <automerge-c/utils/stack.h>
+#include <automerge-c/utils/string.h>
+
+void AMstackFree(AMstack** stack) {
+    if (stack) {
+        while (*stack) {
+            AMresultFree(AMstackPop(stack, NULL));
+        }
+    }
+}
+
+AMresult* AMstackPop(AMstack** stack, const AMresult* result) {
+    if (!stack) {
+        return NULL;
+    }
+    AMstack** prev = stack;
+    if (result) {
+        while (*prev && ((*prev)->result != result)) {
+            *prev = (*prev)->prev;
+        }
+    }
+    if (!*prev) {
+        return NULL;
+    }
+    AMstack* target = *prev;
+    *prev = target->prev;
+    AMresult* popped = target->result;
+    free(target);
+    return popped;
+}
+
+AMresult* AMstackResult(AMstack** stack, AMresult* result, AMstackCallback callback, void* data) {
+    if (!stack) {
+        if (callback) {
+            /* Create a local stack so that the callback can still examine the
+             * result. */
+            AMstack node = {.result = result, .prev = NULL};
+            AMstack* stack = &node;
+            callback(&stack, data);
+        } else {
+            /* \note There is no reason to call this function when both the
+             *       stack and the callback are null. */
+            fprintf(stderr, "ERROR: NULL AMstackCallback!\n");
+        }
+        /* \note Nothing can be returned without a stack regardless of
+         *       whether or not the callback validated the result. */
+        AMresultFree(result);
+        return NULL;
+    }
+    /* Always push the result onto the stack, even if it's null, so that the
+     * callback can examine it. */
+    AMstack* next = calloc(1, sizeof(AMstack));
+    *next = (AMstack){.result = result, .prev = *stack};
+    AMstack* top = next;
+    *stack = top;
+    if (callback) {
+        if (!callback(stack, data)) {
+            /* The result didn't pass the callback's examination. */
+            return NULL;
+        }
+    } else {
+        /* Report an obvious error. */
+        if (result) {
+            AMbyteSpan const err_msg = AMresultError(result);
+            if (err_msg.src && err_msg.count) {
+                /* \note The callback may be null because the result is supposed
+                 *       to be examined externally so return it despite an
+                 *       error. */
+                char* const cstr = AMstrdup(err_msg, NULL);
+                fprintf(stderr, "WARNING: %s.\n", cstr);
+                free(cstr);
+            }
+        } else {
+            /* \note There's no reason to call this function when both the
+             *       result and the callback are null. */
+            fprintf(stderr, "ERROR: NULL AMresult*!\n");
+            return NULL;
+        }
+    }
+    return result;
+}
+
+AMitem* AMstackItem(AMstack** stack, AMresult* result, AMstackCallback callback, void* data) {
+    AMitems items = AMstackItems(stack, result, callback, data);
+    return AMitemsNext(&items, 1);
+}
+
+AMitems AMstackItems(AMstack** stack, AMresult* result, AMstackCallback callback, void* data) {
+    return (AMstackResult(stack, result, callback, data)) ? AMresultItems(result) : (AMitems){0};
+}
+
+size_t AMstackSize(AMstack const* const stack) {
+    if (!stack) {
+        return 0;
+    }
+    size_t count = 0;
+    AMstack const* prev = stack;
+    while (prev) {
+        ++count;
+        prev = prev->prev;
+    }
+    return count;
+}

data/vendor/automerge-rust/automerge-c/src/utils/stack_callback_data.c

@@ -0,0 +1,9 @@
+#include <stdlib.h>
+
+#include <automerge-c/utils/stack_callback_data.h>
+
+AMstackCallbackData* AMstackCallbackDataInit(AMvalType const bitmask, char const* const file, int const line) {
+    AMstackCallbackData* data = malloc(sizeof(AMstackCallbackData));
+    *data = (AMstackCallbackData){.bitmask = bitmask, .file = file, .line = line};
+    return data;
+}

data/vendor/automerge-rust/automerge-c/src/utils/string.c

@@ -0,0 +1,46 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include <automerge-c/utils/string.h>
+
+char* AMstrdup(AMbyteSpan const str, char const* nul) {
+    if (!str.src) {
+        return NULL;
+    } else if (!str.count) {
+        return strdup("");
+    }
+    nul = (nul) ? nul : "\\0";
+    size_t const nul_len = strlen(nul);
+    char* dup = NULL;
+    size_t dup_len = 0;
+    char const* begin = (char const*) str.src;
+    char const* end = begin;
+    for (size_t i = 0; i != str.count; ++i, ++end) {
+        if (!*end) {
+            size_t const len = end - begin;
+            size_t const alloc_len = dup_len + len + nul_len;
+            if (dup) {
+                dup = realloc(dup, alloc_len + 1);
+            } else {
+                dup = malloc(alloc_len + 1);
+            }
+            memcpy(dup + dup_len, begin, len);
+            memcpy(dup + dup_len + len, nul, nul_len);
+            dup[alloc_len] = '\0';
+            begin = end + 1;
+            dup_len = alloc_len;
+        }
+    }
+    if (begin != end) {
+        size_t const len = end - begin;
+        size_t const alloc_len = dup_len + len;
+        if (dup) {
+            dup = realloc(dup, alloc_len + 1);
+        } else {
+            dup = malloc(alloc_len + 1);
+        }
+        memcpy(dup + dup_len, begin, len);
+        dup[alloc_len] = '\0';
+    }
+    return dup;
+}

data/vendor/automerge-rust/automerge-c/test/CMakeLists.txt

@@ -0,0 +1,67 @@
+cmake_minimum_required(VERSION 3.25 FATAL_ERROR)
+
+find_package(cmocka CONFIG REQUIRED)
+
+add_executable(
+    ${LIBRARY_NAME}_test
+        actor_id_tests.c
+        base_state.c
+        byte_span_tests.c
+        cmocka_utils.c
+        cursor_tests.c
+        enum_string_tests.c
+        doc_state.c
+        doc_tests.c
+        item_tests.c
+        list_tests.c
+        macro_utils.c
+        main.c
+        map_tests.c
+        mark_tests.c
+        str_utils.c
+        ported_wasm/basic_tests.c
+        ported_wasm/cursor_tests.c
+        ported_wasm/suite.c
+        ported_wasm/sync_tests.c
+)
+
+set_target_properties(${LIBRARY_NAME}_test PROPERTIES LINKER_LANGUAGE C)
+
+if(WIN32)
+    set(CMOCKA "cmocka::cmocka")
+else()
+    set(CMOCKA "cmocka")
+endif()
+
+target_link_libraries(${LIBRARY_NAME}_test PRIVATE ${CMOCKA} ${LIBRARY_NAME})
+
+add_dependencies(${LIBRARY_NAME}_test ${BINDINGS_NAME}_artifacts)
+
+add_custom_command(
+    TARGET ${LIBRARY_NAME}_test
+    POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/files ${CMAKE_CURRENT_BINARY_DIR}/files
+    COMMENT "Copying the test input files into the tests directory..."
+)
+
+if(BUILD_SHARED_LIBS AND WIN32)
+    add_custom_command(
+        TARGET ${LIBRARY_NAME}_test
+        POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:${LIBRARY_NAME}> $<TARGET_FILE_DIR:${LIBRARY_NAME}_test>
+        COMMENT "Copying the DLL into the tests directory..."
+        VERBATIM
+    )
+endif()
+
+add_test(NAME ${LIBRARY_NAME}_test COMMAND ${LIBRARY_NAME}_test)
+
+add_custom_command(
+    TARGET ${LIBRARY_NAME}_test
+    POST_BUILD
+    COMMAND
+        ${CMAKE_CTEST_COMMAND} --build-config $<CONFIG> --output-on-failure
+    COMMENT
+        "Running the test(s)..."
+    VERBATIM
+)