101 lines
4.0 KiB
C++
101 lines
4.0 KiB
C++
#include <gtest/gtest.h>
|
|
#include <atomic>
|
|
#include <chrono>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <thread>
|
|
#include <vector>
|
|
#include "renderive/base/observer/Observer.hpp"
|
|
struct Observer_Test_Observation {
|
|
int value{};
|
|
};
|
|
struct Observer_Test_Time_Source {
|
|
std::shared_ptr<std::atomic<std::uint64_t>> time{std::make_shared<std::atomic<std::uint64_t>>(10)};
|
|
std::uint64_t now_ns() const noexcept {
|
|
return time->fetch_add(5, std::memory_order_relaxed);
|
|
}
|
|
};
|
|
struct Observer_Test_Recorder {
|
|
static constexpr bool enabled = true;
|
|
std::shared_ptr<int> value{std::make_shared<int>()};
|
|
void observe(const Observer_Test_Observation& observation) noexcept {
|
|
*value = observation.value;
|
|
}
|
|
};
|
|
using Observer_Test_State = Observer_State<Observer_Test_Recorder, Observer_Test_Time_Source>;
|
|
static_assert(Observation_Struct<Observer_Test_Observation>);
|
|
static_assert(Observer_Time_Source<Observer_Test_Time_Source>);
|
|
static_assert(Struct_Observer<Observer_Test_Recorder, Observer_Test_Observation>);
|
|
static_assert(Timed_Struct_Observer<Observer_Test_State, Observer_Test_Observation>);
|
|
TEST(observer_state_test, forwards_observation_structure) {
|
|
Observer_Test_Recorder recorder;
|
|
Observer_Test_State observer(recorder, Observer_Test_Time_Source{});
|
|
observer.observe(Observer_Test_Observation{7});
|
|
EXPECT_EQ(*recorder.value, 7);
|
|
}
|
|
TEST(observer_state_test, owns_time_source) {
|
|
Observer_Test_State observer;
|
|
EXPECT_EQ(observer.now_ns(), 10);
|
|
EXPECT_EQ(observer.now_ns(), 15);
|
|
}
|
|
TEST(disabled_observer_test, accepts_any_observation_structure) {
|
|
Observer_State<> observer;
|
|
EXPECT_NO_THROW(observer.observe(Observer_Test_Observation{7}));
|
|
EXPECT_GT(observer.now_ns(), 0);
|
|
}
|
|
struct Observer_Test_Concurrent_Time_Source_Data {
|
|
std::atomic<int> active{};
|
|
std::atomic<bool> overlap{};
|
|
std::uint64_t value{};
|
|
};
|
|
struct Observer_Test_Concurrent_Time_Source {
|
|
std::shared_ptr<Observer_Test_Concurrent_Time_Source_Data> data{std::make_shared<Observer_Test_Concurrent_Time_Source_Data>()};
|
|
std::uint64_t now_ns() const noexcept {
|
|
if (data->active.fetch_add(1, std::memory_order_acq_rel) != 0) {
|
|
data->overlap.store(true, std::memory_order_release);
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(2));
|
|
const auto value = data->value++;
|
|
data->active.fetch_sub(1, std::memory_order_acq_rel);
|
|
return value;
|
|
}
|
|
};
|
|
TEST(observer_state_test, serializes_time_source_access) {
|
|
Observer_Test_Concurrent_Time_Source time_source;
|
|
const auto data = time_source.data;
|
|
Observer_State<Disabled_Observer, Observer_Test_Concurrent_Time_Source> observer(Disabled_Observer{}, std::move(time_source));
|
|
std::atomic<bool> start{};
|
|
std::vector<std::thread> threads;
|
|
for (int index = 0; index < 8; ++index) {
|
|
threads.emplace_back([&] {
|
|
while (!start.load(std::memory_order_acquire)) {
|
|
std::this_thread::yield();
|
|
}
|
|
observer.now_ns();
|
|
});
|
|
}
|
|
start.store(true, std::memory_order_release);
|
|
for (auto& thread : threads) {
|
|
thread.join();
|
|
}
|
|
EXPECT_FALSE(data->overlap.load(std::memory_order_acquire));
|
|
EXPECT_EQ(data->value, 8);
|
|
}
|
|
struct Observer_Test_Throwing_Move_Time_Source {
|
|
Observer_Test_Throwing_Move_Time_Source() = default;
|
|
Observer_Test_Throwing_Move_Time_Source(Observer_Test_Throwing_Move_Time_Source&&) {
|
|
throw std::runtime_error("time source move failed");
|
|
}
|
|
Observer_Test_Throwing_Move_Time_Source& operator=(Observer_Test_Throwing_Move_Time_Source&&) = delete;
|
|
std::uint64_t now_ns() const noexcept {
|
|
return 0;
|
|
}
|
|
};
|
|
TEST(observer_state_test, move_constructor_propagates_throwing_time_source_move) {
|
|
using State = Observer_State<Disabled_Observer, Observer_Test_Throwing_Move_Time_Source>;
|
|
static_assert(std::move_constructible<Observer_Test_Throwing_Move_Time_Source>);
|
|
static_assert(!std::is_nothrow_move_constructible_v<State>);
|
|
State source;
|
|
EXPECT_THROW(State(std::move(source)), std::runtime_error);
|
|
}
|