勉强完成延迟很高

web_server/tests/Gallery_Frame_Clock_Tests.cpp

@@ -0,0 +1,65 @@
+#include <gtest/gtest.h>
+#include <web_server/src/detail/Gallery_Frame_Clock.hpp>
+#include <asio/thread_pool.hpp>
+#include <chrono>
+#include <condition_variable>
+#include <exception>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace aethera::web::detail {
+TEST(Gallery_Frame_Clock, Produces_One_Monotonic_Absolute_Timeline) {
+    asio::thread_pool pool(1);
+    std::mutex mutex;
+    std::condition_variable condition;
+    std::vector<Plot_Render_Tick> ticks;
+    std::exception_ptr failure;
+    {
+        Gallery_Frame_Clock clock(
+            pool.get_executor(), 100.0,
+            [&](Plot_Render_Tick tick) {
+                std::lock_guard lock(mutex);
+                ticks.push_back(tick);
+                condition.notify_all();
+            },
+            [&](std::exception_ptr value) {
+                std::lock_guard lock(mutex);
+                failure = std::move(value);
+                condition.notify_all();
+            });
+        clock.start();
+        clock.start();
+        {
+            std::unique_lock lock(mutex);
+            ASSERT_TRUE(condition.wait_for(lock, std::chrono::seconds(2), [&] {
+                return ticks.size() >= 8 || failure;
+            }));
+            ASSERT_FALSE(failure);
+            ASSERT_GE(ticks.size(), 8U);
+            for (std::size_t index = 1; index < ticks.size(); ++index) {
+                EXPECT_GT(ticks[index].sequence, ticks[index - 1].sequence);
+                EXPECT_GT(ticks[index].time_milliseconds,
+                          ticks[index - 1].time_milliseconds);
+            }
+            EXPECT_NEAR(ticks.front().time_milliseconds,
+                        static_cast<double>(ticks.front().sequence) * 10.0,
+                        0.001);
+        }
+        clock.stop();
+        std::this_thread::sleep_for(std::chrono::milliseconds(30));
+        std::size_t stopped_count{};
+        {
+            std::lock_guard lock(mutex);
+            stopped_count = ticks.size();
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(30));
+        {
+            std::lock_guard lock(mutex);
+            EXPECT_EQ(ticks.size(), stopped_count);
+        }
+    }
+    pool.stop();
+    pool.join();
+}
+}