Remove googletest (#178)

2025-08-16 23:09:13 +08:00
parent e77f182fcd
commit 08b41f15c2
46 changed files with 4446 additions and 4285 deletions
--- a/tests/unit/Async/Event.cpp
+++ b/tests/unit/Async/Event.cpp
@@ -5,61 +5,63 @@ namespace clice::testing {

 namespace {

-TEST(Async, Event) {
-    async::Event event;
+suite<"Async"> suite = [] {
+    test("Event") = [] {
+        async::Event event;

-    int x = 0;
+        int x = 0;

-    auto task1 = [&]() -> async::Task<> {
-        EXPECT_EQ(x, 0);
-        co_await event;
-        EXPECT_EQ(x, 1);
-        x = 2;
+        auto task1 = [&]() -> async::Task<> {
+            expect(that % x == 0);
+            co_await event;
+            expect(that % x == 1);
+            x = 2;
+        };
+
+        auto task2 = [&]() -> async::Task<> {
+            expect(that % x == 0);
+            co_await event;
+            expect(that % x == 2);
+            x = 3;
+        };
+
+        auto main = [&]() -> async::Task<> {
+            x = 1;
+            event.set();
+            co_return;
+        };
+
+        async::run(task1(), task2(), main());
    };

-    auto task2 = [&]() -> async::Task<> {
-        EXPECT_EQ(x, 0);
-        co_await event;
-        EXPECT_EQ(x, 2);
-        x = 3;
+    test("EventClear") = [] {
+        async::Event event;
+
+        int x = 0;
+
+        auto task1 = [&]() -> async::Task<> {
+            expect(that % x == 0);
+            co_await event;
+            expect(that % x == 1);
+            x = 2;
+        };
+
+        auto task2 = [&]() -> async::Task<> {
+            expect(that % x == 0);
+            co_await event;
+            expect(that % x == 2);
+            x = 3;
+        };
+
+        auto main = [&]() -> async::Task<> {
+            x = 1;
+            event.set();
+            co_return;
+        };
+
+        async::run(task1(), task2(), main());
    };
-
-    auto main = [&]() -> async::Task<> {
-        x = 1;
-        event.set();
-        co_return;
-    };
-
-    async::run(task1(), task2(), main());
-}
-
-TEST(Async, EventClear) {
-    async::Event event;
-
-    int x = 0;
-
-    auto task1 = [&]() -> async::Task<> {
-        EXPECT_EQ(x, 0);
-        co_await event;
-        EXPECT_EQ(x, 1);
-        x = 2;
-    };
-
-    auto task2 = [&]() -> async::Task<> {
-        EXPECT_EQ(x, 0);
-        co_await event;
-        EXPECT_EQ(x, 2);
-        x = 3;
-    };
-
-    auto main = [&]() -> async::Task<> {
-        x = 1;
-        event.set();
-        co_return;
-    };
-
-    async::run(task1(), task2(), main());
-}
+};

 }  // namespace

--- a/tests/unit/Async/FileSystem.cpp
+++ b/tests/unit/Async/FileSystem.cpp
@@ -6,39 +6,41 @@ namespace clice::testing {

 namespace {

-TEST(Async, FileSystemRead) {
-    auto path = fs::createTemporaryFile("prefix", "suffix");
-    EXPECT_TRUE(path.has_value());
+suite<"Async"> suite = [] {
+    test("FileSystemRead") = [] {
+        auto path = fs::createTemporaryFile("prefix", "suffix");
+        expect(that % path.has_value());

-    auto result = fs::write(*path, "hello");
-    EXPECT_TRUE(result.has_value());
+        auto result = fs::write(*path, "hello");
+        expect(that % result.has_value());

-    auto main = [&] -> async::Task<> {
-        auto content = co_await async::fs::read(*path);
-        EXPECT_TRUE(content.has_value());
-        EXPECT_EQ(*content, "hello");
+        auto main = [&] -> async::Task<> {
+            auto content = co_await async::fs::read(*path);
+            expect(that % content.has_value());
+            expect(that % *content == std::string_view("hello"));
+        };
+
+        async::run(main());
    };

-    async::run(main());
-}
+    test("FileSystemWrite") = [] {
+        auto path = fs::createTemporaryFile("prefix", "suffix");
+        expect(that % path.has_value());

-TEST(Async, FileSystemWrite) {
-    auto path = fs::createTemporaryFile("prefix", "suffix");
-    EXPECT_TRUE(path.has_value());
+        auto main = [&] -> async::Task<> {
+            char buffer[] = "hello";

-    auto main = [&] -> async::Task<> {
-        char buffer[] = "hello";
+            auto result = co_await async::fs::write(*path, buffer, 5);
+            expect(that % result.has_value());
+        };

-        auto result = co_await async::fs::write(*path, buffer, 5);
-        EXPECT_TRUE(result.has_value());
+        async::run(main());
+
+        auto content = fs::read(*path);
+        expect(that % content.has_value());
+        expect(that % *content == std::string_view("hello"));
    };
-
-    async::run(main());
-
-    auto content = fs::read(*path);
-    EXPECT_TRUE(content.has_value());
-    EXPECT_EQ(*content, "hello");
-}
+};

 }  // namespace

--- a/tests/unit/Async/Gather.cpp
+++ b/tests/unit/Async/Gather.cpp
@@ -5,63 +5,65 @@ namespace clice::testing {

 namespace {

-TEST(Async, GatherPack) {
-    int x = 0;
+suite<"Async"> suite = [] {
+    test("GatherPack") = [] {
+        int x = 0;

-    auto task_gen = [&]() -> async::Task<int> {
-        co_await async::sleep(100);
-        x += 1;
-        co_return x;
+        auto task_gen = [&]() -> async::Task<int> {
+            co_await async::sleep(100);
+            x += 1;
+            co_return x;
+        };
+
+        auto [a, b, c] = async::run(task_gen(), task_gen(), task_gen());
+
+        expect(that % a == 1);
+        expect(that % b == 2);
+        expect(that % c == 3);
    };

-    auto [a, b, c] = async::run(task_gen(), task_gen(), task_gen());
+    test("GatherRange") = [] {
+        std::vector<int> args;
+        for(int i = 0; i < 30; ++i) {
+            args.push_back(i);
+        }

-    EXPECT_EQ(a, 1);
-    EXPECT_EQ(b, 2);
-    EXPECT_EQ(c, 3);
-}
+        std::vector<int> results;

-TEST(Async, GatherRange) {
-    std::vector<int> args;
-    for(int i = 0; i < 30; ++i) {
-        args.push_back(i);
-    }
+        auto task_gen = [&](int x) -> async::Task<bool> {
+            co_await async::sleep(10);
+            results.push_back(x);
+            co_return true;
+        };

-    std::vector<int> results;
+        auto core = async::gather(args, task_gen);
+        async::run(core);

-    auto task_gen = [&](int x) -> async::Task<bool> {
-        co_await async::sleep(10);
-        results.push_back(x);
-        co_return true;
+        expect(that % args == results);
+        expect(that % core.result() == true);
    };

-    auto core = async::gather(args, task_gen);
-    async::run(core);
+    test("GatherCancel") = [] {
+        std::vector<int> args;
+        for(int i = 0; i < 30; ++i) {
+            args.push_back(i);
+        }

-    EXPECT_EQ(args, results);
-    EXPECT_EQ(core.result(), true);
-}
+        std::vector<int> results;

-TEST(Async, GatherCancel) {
-    std::vector<int> args;
-    for(int i = 0; i < 30; ++i) {
-        args.push_back(i);
-    }
+        auto task_gen = [&](int x) -> async::Task<bool> {
+            co_await async::sleep(10);
+            results.push_back(x);
+            co_return false;
+        };

-    std::vector<int> results;
+        auto core = async::gather(args, task_gen);
+        async::run(core);

-    auto task_gen = [&](int x) -> async::Task<bool> {
-        co_await async::sleep(10);
-        results.push_back(x);
-        co_return false;
+        expect(that % results.size() == 1);
+        expect(that % core.result() == false);
    };
-
-    auto core = async::gather(args, task_gen);
-    async::run(core);
-
-    EXPECT_EQ(results.size(), 1);
-    EXPECT_EQ(core.result(), false);
-}
+};

 }  // namespace

--- a/tests/unit/Async/Lock.cpp
+++ b/tests/unit/Async/Lock.cpp
@@ -5,75 +5,77 @@ namespace clice::testing {

 namespace {

-TEST(Async, Lock) {
-    async::Lock lock;
+suite<"Async"> suite = [] {
+    test("Lock") = [] {
+        async::Lock lock;

-    int x = 0;
+        int x = 0;

-    auto task1 = [&]() -> async::Task<> {
-        auto guard = co_await lock.try_lock();
-        co_await async::sleep(5);
-        EXPECT_EQ(x, 0);
-        co_await async::sleep(10);
-        EXPECT_EQ(x, 0);
-        co_await async::sleep(5);
-        x = 1;
+        auto task1 = [&]() -> async::Task<> {
+            auto guard = co_await lock.try_lock();
+            co_await async::sleep(5);
+            expect(that % x == 0);
+            co_await async::sleep(10);
+            expect(that % x == 0);
+            co_await async::sleep(5);
+            x = 1;
+        };
+
+        auto task2 = [&]() -> async::Task<> {
+            auto guard = co_await lock.try_lock();
+            co_await async::sleep(5);
+            expect(that % x == 1);
+            co_await async::sleep(5);
+            expect(that % x == 1);
+            co_await async::sleep(10);
+            x = 2;
+        };
+
+        auto task3 = [&]() -> async::Task<> {
+            auto guard = co_await lock.try_lock();
+            co_await async::sleep(10);
+            expect(that % x == 2);
+            co_await async::sleep(5);
+            expect(that % x == 2);
+            co_await async::sleep(5);
+        };
+
+        async::run(task1(), task2(), task3());
    };

-    auto task2 = [&]() -> async::Task<> {
-        auto guard = co_await lock.try_lock();
-        co_await async::sleep(5);
-        EXPECT_EQ(x, 1);
-        co_await async::sleep(5);
-        EXPECT_EQ(x, 1);
-        co_await async::sleep(10);
-        x = 2;
+    test("LockCancel") = [] {
+        async::Lock lock;
+
+        int x = 0;
+        int y = 0;
+
+        auto task = [&]() -> async::Task<> {
+            x += 1;
+            auto guard = co_await lock.try_lock();
+            co_await async::sleep(100);
+            y += 1;
+        };
+
+        auto task1 = task();
+        auto task2 = task();
+        auto task3 = task();
+
+        auto cancel = [&task2]() -> async::Task<> {
+            co_await async::sleep(10);
+            task2.cancel();
+            task2.dispose();
+        };
+
+        task1.schedule();
+        task2.schedule();
+        task3.schedule();
+
+        async::run(cancel());
+
+        expect(that % x == 3);
+        expect(that % y == 2);
    };
-
-    auto task3 = [&]() -> async::Task<> {
-        auto guard = co_await lock.try_lock();
-        co_await async::sleep(10);
-        EXPECT_EQ(x, 2);
-        co_await async::sleep(5);
-        EXPECT_EQ(x, 2);
-        co_await async::sleep(5);
-    };
-
-    async::run(task1(), task2(), task3());
-}
-
-TEST(Async, LockCancel) {
-    async::Lock lock;
-
-    int x = 0;
-    int y = 0;
-
-    auto task = [&]() -> async::Task<> {
-        x += 1;
-        auto guard = co_await lock.try_lock();
-        co_await async::sleep(100);
-        y += 1;
-    };
-
-    auto task1 = task();
-    auto task2 = task();
-    auto task3 = task();
-
-    auto cancel = [&task2]() -> async::Task<> {
-        co_await async::sleep(10);
-        task2.cancel();
-        task2.dispose();
-    };
-
-    task1.schedule();
-    task2.schedule();
-    task3.schedule();
-
-    async::run(cancel());
-
-    EXPECT_EQ(x, 3);
-    EXPECT_EQ(y, 2);
-}
+};

 }  // namespace

--- a/tests/unit/Async/Sleep.cpp
+++ b/tests/unit/Async/Sleep.cpp
@@ -5,19 +5,21 @@ namespace clice::testing {

 namespace {

-TEST(Async, Sleep) {
-    int x = 1;
-    auto task_gen = [&]() -> async::Task<> {
-        x = 2;
-        co_await async::sleep(100);
-        x = 3;
+suite<"Async"> suite = [] {
+    test("Sleep") = [] {
+        int x = 1;
+        auto task_gen = [&]() -> async::Task<> {
+            x = 2;
+            co_await async::sleep(100);
+            x = 3;
+        };
+
+        auto task = task_gen();
+        async::run(task);
+
+        expect(that % x == 3);
    };
-
-    auto task = task_gen();
-    async::run(task);
-
-    EXPECT_EQ(x, 3);
-}
+};

 }  // namespace

--- a/tests/unit/Async/Task.cpp
+++ b/tests/unit/Async/Task.cpp
@@ -6,121 +6,123 @@ namespace clice::testing {

 namespace {

-TEST(Async, Run) {
-    async::run();
-}
-
-TEST(Async, TaskSchedule) {
-    auto task_gen = []() -> async::Task<int> {
-        co_return 1;
+suite<"Async"> suite = [] {
+    test("Run") = [] {
+        async::run();
    };

-    auto task = task_gen();
-    task.schedule();
+    test("TaskSchedule") = [] {
+        auto task_gen = []() -> async::Task<int> {
+            co_return 1;
+        };

-    async::run();
+        auto task = task_gen();
+        task.schedule();

-    EXPECT_TRUE(task.done());
-    EXPECT_EQ(task.result(), 1);
-}
+        async::run();

-TEST(Async, TaskDispose) {
-    static int x = 1;
-
-    struct X {
-        ~X() {
-            x += 1;
-        }
+        expect(that % task.done());
+        expect(that % task.result() == 1);
    };

-    auto my_task = [&]() -> async::Task<> {
-        X x;
-        co_await async::sleep(300);
-    };
+    test("TaskDispose") = [] {
+        static int x = 1;

-    auto task = my_task();
-    task.schedule();
-    task.dispose();
-    async::run();
+        struct X {
+            ~X() {
+                x += 1;
+            }
+        };

-    EXPECT_EQ(x, 2);
+        auto my_task = [&]() -> async::Task<> {
+            X x;
+            co_await async::sleep(300);
+        };

-    auto main = [&]() -> async::Task<> {
        auto task = my_task();
        task.schedule();
-        co_await async::sleep(100);
-        task.cancel();
        task.dispose();
+        async::run();
+
+        expect(that % x == 2);
+
+        auto main = [&]() -> async::Task<> {
+            auto task = my_task();
+            task.schedule();
+            co_await async::sleep(100);
+            task.cancel();
+            task.dispose();
+        };
+
+        async::run(main());
+
+        expect(that % x == 3);
    };

-    async::run(main());
+    test("TaskCancel") = [] {
+        int x = 1;

-    EXPECT_EQ(x, 3);
-}
+        auto task1 = [&]() -> async::Task<> {
+            x = 2;
+            co_await async::sleep(300);
+            x = 3;
+        };

-TEST(Async, TaskCancel) {
-    int x = 1;
+        auto main = [&]() -> async::Task<> {
+            auto task = task1();
+            task.schedule();
+            co_await async::sleep(100);
+            task.cancel();
+            task.dispose();
+        };

-    auto task1 = [&]() -> async::Task<> {
-        x = 2;
-        co_await async::sleep(300);
-        x = 3;
+        async::run(main());
+
+        expect(that % x == 2);
    };

-    auto main = [&]() -> async::Task<> {
-        auto task = task1();
-        task.schedule();
-        co_await async::sleep(100);
-        task.cancel();
-        task.dispose();
+    test("TaskCancelRecursively") = [] {
+        int x = 0;
+        int y = 0;
+        int z = 0;
+
+        auto task1 = [&]() -> async::Task<> {
+            x = 1;
+            co_await async::sleep(300);
+            clice::println("Task1 done");
+            x = 2;
+        };
+
+        auto task2 = [&]() -> async::Task<> {
+            auto task = task1();
+            y = 1;
+            co_await task;
+            y = 2;
+        };
+
+        auto task3 = [&]() -> async::Task<> {
+            auto task = task2();
+            z = 1;
+            co_await task;
+            z = 2;
+        };
+
+        auto main = [&]() -> async::Task<> {
+            auto task = task3();
+            task.schedule();
+            co_await async::sleep(100);
+            task.cancel();
+            task.dispose();
+        };
+
+        async::run(main());
+
+        /// All tasks should be cancelled recursively.
+        expect(that % x == 1);
+        expect(that % y == 1);
+        expect(that % z == 1);
    };
-
-    async::run(main());
-
-    EXPECT_EQ(x, 2);
-}
-
-TEST(Async, TaskCancelRecursively) {
-    int x = 0;
-    int y = 0;
-    int z = 0;
-
-    auto task1 = [&]() -> async::Task<> {
-        x = 1;
-        co_await async::sleep(300);
-        clice::println("Task1 done");
-        x = 2;
-    };
-
-    auto task2 = [&]() -> async::Task<> {
-        auto task = task1();
-        y = 1;
-        co_await task;
-        y = 2;
-    };
-
-    auto task3 = [&]() -> async::Task<> {
-        auto task = task2();
-        z = 1;
-        co_await task;
-        z = 2;
-    };
-
-    auto main = [&]() -> async::Task<> {
-        auto task = task3();
-        task.schedule();
-        co_await async::sleep(100);
-        task.cancel();
-        task.dispose();
-    };
-
-    async::run(main());
-
-    /// All tasks should be cancelled recursively.
-    EXPECT_EQ(x, 1);
-    EXPECT_EQ(y, 1);
-    EXPECT_EQ(z, 1);
-}
+};

 }  // namespace

--- a/tests/unit/Async/ThreadPool.cpp
+++ b/tests/unit/Async/ThreadPool.cpp
@@ -5,36 +5,38 @@ namespace clice::testing {

 namespace {

-TEST(Async, ThreadPool) {
-    auto task_gen = []() -> async::Task<std::thread::id> {
-        co_return co_await async::submit([]() {
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
-            return std::this_thread::get_id();
-        });
+suite<"Async"> suite = [] {
+    test("ThreadPool") = [] {
+        auto task_gen = []() -> async::Task<std::thread::id> {
+            co_return co_await async::submit([]() {
+                std::this_thread::sleep_for(std::chrono::milliseconds(100));
+                return std::this_thread::get_id();
+            });
+        };
+
+        auto task1 = task_gen();
+        auto task2 = task_gen();
+        auto task3 = task_gen();
+
+        task1.schedule();
+        task2.schedule();
+        task3.schedule();
+
+        async::run();
+
+        expect(that % task1.done());
+        expect(that % task2.done());
+        expect(that % task3.done());
+
+        auto id1 = task1.result();
+        auto id2 = task2.result();
+        auto id3 = task3.result();
+
+        expect(that % id1 != id2);
+        expect(that % id1 != id3);
+        expect(that % id2 != id3);
    };
-
-    auto task1 = task_gen();
-    auto task2 = task_gen();
-    auto task3 = task_gen();
-
-    task1.schedule();
-    task2.schedule();
-    task3.schedule();
-
-    async::run();
-
-    EXPECT_TRUE(task1.done());
-    EXPECT_TRUE(task2.done());
-    EXPECT_TRUE(task3.done());
-
-    auto id1 = task1.result();
-    auto id2 = task2.result();
-    auto id3 = task3.result();
-
-    EXPECT_NE(id1, id2);
-    EXPECT_NE(id1, id3);
-    EXPECT_NE(id2, id3);
-}
+};

 }  // namespace