thread_safe_object_test.cpp

#include <houseguest/thread_safe_object.hpp>

#include <algorithm>
#include <future>
#include <thread>
#include <vector>

#include <gtest/gtest.h>

#include <houseguest/synchronize.hpp>

TEST(ThreadSafeObject, default_ctor) // NOLINT
{
    houseguest::threadsafe_object<std::vector<int>> tsv;
    auto handle = tsv.read();
    ASSERT_TRUE(handle->empty());
    ASSERT_EQ(0, handle->size());
}

TEST(ThreadSafeObject, args_ctor) // NOLINT
{
    houseguest::threadsafe_object<std::vector<int>> tsv{10};
    auto handle = tsv.read();
    ASSERT_FALSE(handle->empty());
    ASSERT_EQ(1, handle->size());
}

TEST(ThreadSafeObject, write_handle) // NOLINT
{
    houseguest::threadsafe_object<std::vector<int>> tsv;
    auto handle = tsv.write();
    handle->push_back(10);
    ASSERT_FALSE(handle->empty());
    ASSERT_EQ(1, handle->size());
}

TEST(ThreadSafeObject, multi_thread_read) // NOLINT
{
    houseguest::threadsafe_object<int> tsi;

    std::mutex m;
    auto make_thread_fn = [&m, &tsi](auto & local_promise, auto & local_cv) {
        return [&tsi, &m, &local_promise, &local_cv]() {
            auto handle = tsi.read();
            houseguest::synchronize_unique(
                m, [&local_promise, &local_cv](auto lock) {
                    local_promise.set_value();
                    local_cv.wait(lock);
                });
        };
    };

    houseguest::synchronize_unique(m, [&make_thread_fn](auto lock) {
        std::promise<void> p1;
        std::promise<void> p2;
        std::condition_variable c1;
        std::condition_variable c2;

        std::thread ts[] = {std::thread{make_thread_fn(p1, c1)},
                            std::thread{make_thread_fn(p2, c2)}};

        lock.unlock();
        p1.get_future().get();
        p2.get_future().get();
        lock.lock();
        c1.notify_one();
        c2.notify_one();
        lock.unlock();
        std::for_each(std::begin(ts), std::end(ts), [](auto & t) { t.join(); });
    });
}