feat replace gtest by doctest

2024-03-30 23:40:17 +08:00 · 2024-03-30 23:40:17 +08:00 · 7c1582769e
commit 7c1582769e
parent c7fe469c1b
28 changed files with 15471 additions and 445 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -17,6 +17,7 @@ set(BUILD_STATIC ON)
 set(BUILD_RTTR_DYNAMIC OFF)
 set(BUILD_UNIT_TESTS OFF)
 set(BUILD_EXAMPLES OFF)
+add_library(test_main STATIC src/sled/testing/test_main.cc)
 add_library(sled STATIC "")

 add_subdirectory(3party/gperftools EXCLUDE_FROM_ALL)
@ -42,6 +43,7 @@ endif()
 # add_subdirectory(3party/eigen EXCLUDE_FROM_ALL)
 target_include_directories(sled PUBLIC src/ 3party/eigen 3party/inja
                                       3party/rxcpp)
+target_include_directories(test_main PUBLIC src/)
 target_sources(
  sled
  PRIVATE src/sled/async/async.cc
@ -68,6 +70,7 @@ target_sources(
          src/sled/system/thread_pool.cc
          src/sled/task_queue/pending_task_safety_flag.cc
          src/sled/task_queue/task_queue_base.cc
+          src/sled/testing/test.cc
          src/sled/timer/task_queue_timeout.cc
          src/sled/timer/timer.cc
          src/sled/units/time_delta.cc
@ -122,9 +125,6 @@ function(sled_add_test)
  cmake_parse_arguments("${prefix}" "${options}" "${one_value_keywords}"
                        "${multi_value_keywords}" ${ARGN})

-  message(WARNING "SLED_TEST_NAME: ${SLED_TEST_NAME}")
-  message(WARNING "SLED_TEST_SRCS: ${SLED_TEST_SRCS}")
-  message(WARNING "SLED_TEST_LIBS: ${SLED_TEST_LIBS}")
  add_executable(${SLED_TEST_NAME} ${SLED_TEST_SRCS})

  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
@ -134,28 +134,30 @@ function(sled_add_test)

    target_link_options(${SLED_TEST_NAME} PRIVATE ${EXTRA_FLAGS})
  endif()
+  if(MSVC)
+    target_compile_options(${SLED_TEST_NAME} PRIVATE /FI"sled/testing/test.h")
+  else()
+    target_compile_options(${SLED_TEST_NAME} PRIVATE -include
+                                                     sled/testing/test.h)
+  endif()
  target_include_directories(${SLED_TEST_NAME} PRIVATE ${SLED_TEST_INC_DIRS})
-  target_link_libraries(${SLED_TEST_NAME} PRIVATE ${SLED_TEST_LIBS}
-                                                  GTest::gtest)
+  target_link_libraries(${SLED_TEST_NAME} PRIVATE ${SLED_TEST_LIBS})
  add_test(NAME ${SLED_TEST_NAME} COMMAND ${SLED_TEST_NAME})
 endfunction()

 if(SLED_BUILD_TESTS)
-  include(FetchContent)
-  FetchContent_Declare(
-    googletest
-    URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
-  )
-  FetchContent_MakeAvailable(googletest)
+  # include(FetchContent) FetchContent_Declare( googletest URL
+  # https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+  # ) FetchContent_MakeAvailable(googletest)

  sled_add_test(
    NAME
    sled_all_tests
    SRCS
+    src/sled/debugging/demangle_test.cc
    src/sled/async/async_test.cc
    src/sled/any_test.cc
    src/sled/filesystem/path_test.cc
-    src/sled/futures/detail/just_test.cc
    src/sled/log/fmt_test.cc
    src/sled/synchronization/sequence_checker_test.cc
    src/sled/cleanup_test.cc
@ -169,7 +171,7 @@ if(SLED_BUILD_TESTS)
    src/sled/uri_test.cc
    LIBS
    sled
-    GTest::gtest_main)
+    test_main)

  sled_add_test(NAME sled_symbolize_test SRCS
                src/sled/debugging/symbolize_test.cc LIBS sled)
--- a/src/sled/any_test.cc
+++ b/src/sled/any_test.cc
@ -1,48 +1,50 @@
-#include <gtest/gtest.h>
 #include <sled/any.h>
 #include <sled/log/log.h>

-TEST(Any, Assign)
+TEST_SUITE("Any")
 {
-    sled::Any any1;
-    sled::Any any2(any1);
-    sled::Any any3(1);
-    sled::Any any4(any3);
-    sled::Any any5 = 1;
-    EXPECT_FALSE(any1.HasValue());
-    EXPECT_FALSE(any2.HasValue());
-    EXPECT_TRUE(any3.HasValue());
-    EXPECT_TRUE(any4.HasValue());
-    EXPECT_TRUE(any5.HasValue());
-    EXPECT_EQ(any3.Cast<int>(), 1);
-    EXPECT_EQ(any4.Cast<int>(), 1);
-    EXPECT_EQ(any5.Cast<int>(), 1);
-    EXPECT_EQ(any3.CastOr<std::string>("def"), "def");
-    EXPECT_EQ(any4.CastOr<std::string>("def"), "def");
-    EXPECT_EQ(any5.CastOr<std::string>("def"), "def");
-    EXPECT_EQ(any3.CastOr<int>(11), 1);
-}
+    TEST_CASE("Assign")
+    {
+        sled::Any any1;
+        sled::Any any2(any1);
+        sled::Any any3(1);
+        sled::Any any4(any3);
+        sled::Any any5 = 1;
+        CHECK_FALSE(any1.HasValue());
+        CHECK_FALSE(any2.HasValue());
+        CHECK(any3.HasValue());
+        CHECK(any4.HasValue());
+        CHECK(any5.HasValue());
+        CHECK_EQ(any3.Cast<int>(), 1);
+        CHECK_EQ(any4.Cast<int>(), 1);
+        CHECK_EQ(any5.Cast<int>(), 1);
+        CHECK_EQ(any3.CastOr<std::string>("def"), "def");
+        CHECK_EQ(any4.CastOr<std::string>("def"), "def");
+        CHECK_EQ(any5.CastOr<std::string>("def"), "def");
+        CHECK_EQ(any3.CastOr<int>(11), 1);
+    }

-TEST(Any, std_swap)
-{
-    sled::Any a;
-    sled::Any b = 2;
-    EXPECT_FALSE(a.HasValue());
-    EXPECT_TRUE(b.HasValue());
-    std::swap(a, b);
-    EXPECT_TRUE(a.HasValue());
-    EXPECT_FALSE(b.HasValue());
-    EXPECT_EQ(a.Cast<int>(), 2);
-}
+    TEST_CASE("std_swap")
+    {
+        sled::Any a;
+        sled::Any b = 2;
+        CHECK_FALSE(a.HasValue());
+        CHECK(b.HasValue());
+        std::swap(a, b);
+        CHECK(a.HasValue());
+        CHECK_FALSE(b.HasValue());
+        CHECK_EQ(a.Cast<int>(), 2);
+    }

-TEST(Any, custom_swap)
-{
-    sled::Any a;
-    sled::Any b = 2;
-    EXPECT_FALSE(a.HasValue());
-    EXPECT_TRUE(b.HasValue());
-    a.swap(b);
-    EXPECT_TRUE(a.HasValue());
-    EXPECT_FALSE(b.HasValue());
-    EXPECT_EQ(a.Cast<int>(), 2);
+    TEST_CASE("custom_swap")
+    {
+        sled::Any a;
+        sled::Any b = 2;
+        CHECK_FALSE(a.HasValue());
+        CHECK(b.HasValue());
+        a.swap(b);
+        CHECK(a.HasValue());
+        CHECK_FALSE(b.HasValue());
+        CHECK_EQ(a.Cast<int>(), 2);
+    }
 }
--- a/src/sled/async/async_test.cc
+++ b/src/sled/async/async_test.cc
@ -1,31 +1,33 @@
-#include <gtest/gtest.h>
 #include <sled/async/async.h>
 #include <sled/log/log.h>
 #include <sled/system/fiber/wait_group.h>
 #include <sled/system/thread.h>

-TEST(Async, task)
+TEST_SUITE("Async")
 {
-    auto task1 = async::spawn([] { return 42; }).then([](int value) { return value * 3; }).then([](int value) {
-        EXPECT_EQ(value, 126);
-        return value;
-    });
-    task1.wait();
-    EXPECT_EQ(126, task1.get());
-}
+    TEST_CASE("task")
+    {
+        auto task1 = async::spawn([] { return 42; }).then([](int value) { return value * 3; }).then([](int value) {
+            CHECK_EQ(value, 126);
+            return value;
+        });
+        task1.wait();
+        CHECK_EQ(126, task1.get());
+    }

-TEST(Async, parallel_for)
-{
-    const int count = 1000;
-    std::vector<int> values(count);
-    async::parallel_for(async::irange(0, count), [&values](int x) {
-        EXPECT_FALSE(values[x]);
-        values[x] = true;
-    });
-    for (int i = 0; i < count; i++) { EXPECT_TRUE(values[i]) << i; }
-}
+    TEST_CASE("parallel_for")
+    {
+        const int count = 1000;
+        std::vector<int> values(count);
+        async::parallel_for(async::irange(0, count), [&values](int x) {
+            CHECK_FALSE(values[x]);
+            values[x] = true;
+        });
+        for (int i = 0; i < count; i++) { CHECK(values[i]); }
+    }

-TEST(Async, parallel_reduce)
-{
-    auto r = async::parallel_reduce(async::irange(1, 5), 0, [](int x, int y) { return x + y; });
+    TEST_CASE("parallel_reduce")
+    {
+        auto r = async::parallel_reduce(async::irange(1, 5), 0, [](int x, int y) { return x + y; });
+    }
 }
--- a/src/sled/cleanup_test.cc
+++ b/src/sled/cleanup_test.cc
@ -1,16 +1,18 @@
-#include <gtest/gtest.h>
 #include <sled/cleanup.h>
 #include <sled/random.h>

-TEST(Cleanup, TestCleanup)
+TEST_SUITE("Cleanup")
 {
-    sled::Random rand(1314);
-    for (int i = 0; i < 100; ++i) {
-        int a = rand.Rand(10000);
-        int b = rand.Rand(10000, 20000);
-        {
-            sled::Cleanup<> c([=, &a]() { a = b; });
+    TEST_CASE("assign")
+    {
+        sled::Random rand(1314);
+        for (int i = 0; i < 100; ++i) {
+            int a = rand.Rand(10000);
+            int b = rand.Rand(10000, 20000);
+            {
+                sled::Cleanup<> c([=, &a]() { a = b; });
+            }
+            CHECK_EQ(a, b);
        }
-        ASSERT_EQ(a, b);
    }
 }
--- a/src/sled/debugging/demangle_test.cc
+++ b/src/sled/debugging/demangle_test.cc
@ -0,0 +1,58 @@
+#include <sled/debugging/demangle.h>
+#include <sled/testing/test.h>
+
+TEST_SUITE("Demangle")
+{
+    TEST_CASE("FunctionTemplate")
+    {
+        char tmp[100];
+
+        // template <typename T>
+        // int foo(T);
+        //
+        // foo<Wrapper<int>>({ .value = 5 });
+        CHECK(sled::Demangle("_Z3fooIiEiT_", tmp, sizeof(tmp)));
+        CHECK_EQ(doctest::toString(tmp), "foo<>()");
+    }
+
+    TEST_CASE("FunctionTemplateWithNesting")
+    {
+        char tmp[100];
+
+        // template <std::integral T>
+        // int foo(T);
+        //
+        // foo<int>(5);
+        CHECK(sled::Demangle("_Z3fooI7WrapperIiEEiT_", tmp, sizeof(tmp)));
+        CHECK_EQ(doctest::toString(tmp), "foo<>()");
+    }
+
+    TEST_CASE("FunctionTemplateWithNonTypeParamConstraint")
+    {
+        char tmp[100];
+
+        // template <typename T>
+        // int foo() requires std::integral<T>;
+        //
+        // foo<int>();
+        CHECK(sled::Demangle("_Z3fooITkSt8integraliEiT_", tmp, sizeof(tmp)));
+        CHECK_EQ(doctest::toString(tmp), "foo<>()");
+    }
+
+    TEST_CASE("AbiTags")
+    {
+        char tmp[100];
+
+        // Mangled name generated via:
+        // struct [[gnu::abi_tag("abc")]] A{};
+        // A a;
+        CHECK(sled::Demangle("_Z1aB3abc", tmp, sizeof(tmp)));
+        CHECK_EQ(doctest::toString(tmp), "a[abi:abc]");
+
+        CHECK(sled::Demangle("_ZN1BC2B3xyzEv", tmp, sizeof(tmp)));
+        CHECK_EQ(doctest::toString(tmp), "B::B[abi:xyz]()");
+
+        CHECK(sled::Demangle("_Z1CB3barB3foov", tmp, sizeof(tmp)));
+        CHECK_EQ(doctest::toString(tmp), "C[abi:bar][abi:foo]()");
+    }
+}
--- a/src/sled/debugging/symbolize_test.cc
+++ b/src/sled/debugging/symbolize_test.cc
@ -1,15 +1,20 @@
-#include <gtest/gtest.h>
 #include <sled/debugging/symbolize.h>
 #include <sled/make_unique.h>

 void
-TestFunc1()
+TrivialFunc()
+{}
+
+static void
+StaticFunc()
 {}

 class Class {
 public:
    Class() {}

+    static void StaticFunc() {}
+
    void MemberFunc1() {}

    int MemberFunc2() { return 0; }
@ -58,20 +63,29 @@ void_cast(TRet (TClass::*mem_func)(Args...))
    return void_casted;
 }

-TEST(Symbolize, base)
+TEST_CASE("Trivial Function")
 {
-    char buf[1024];
-    EXPECT_STREQ("TestFunc1()", TrySymbolize(void_cast(TestFunc1)));
-    EXPECT_STREQ("Class::MemberFunc1()", TrySymbolize(void_cast(&Class::MemberFunc1)));
-    EXPECT_STREQ("Class::MemberFunc2()", TrySymbolize(void_cast(&Class::MemberFunc2)));
-    EXPECT_STREQ("Class::MemberFunc3()", TrySymbolize(void_cast(&Class::MemberFunc3)));
-    EXPECT_STREQ("TrySymbolizeWithLimit()", TrySymbolize(void_cast(&TrySymbolizeWithLimit)));
+    CHECK_EQ(doctest::String("TrivialFunc()"), TrySymbolize(void_cast(TrivialFunc)));
+    CHECK_EQ(doctest::String("TrySymbolizeWithLimit()"), TrySymbolize(void_cast(&TrySymbolizeWithLimit)));
+}
+
+TEST_CASE("Static Function") { CHECK_EQ(doctest::String("StaticFunc()"), TrySymbolize(void_cast(StaticFunc))); }
+
+TEST_CASE("Member Function")
+{
+    CHECK_EQ(doctest::String("Class::MemberFunc1()"), TrySymbolize(void_cast(&Class::MemberFunc1)));
+    CHECK_EQ(doctest::String("Class::MemberFunc2()"), TrySymbolize(void_cast(&Class::MemberFunc2)));
+    CHECK_EQ(doctest::String("Class::MemberFunc3()"), TrySymbolize(void_cast(&Class::MemberFunc3)));
+}
+
+TEST_CASE("Static Member Function")
+{
+    CHECK_EQ(doctest::String("Class::StaticFunc()"), TrySymbolize(void_cast(&Class::StaticFunc)));
 }

 int
 main(int argc, char *argv[])
 {
    sled::InitializeSymbolizer(argv[0]);
-    testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
+    return doctest::Context(argc, argv).run();
 }
--- a/src/sled/exec/just_test.cc
+++ b/src/sled/exec/just_test.cc
@ -1,40 +0,0 @@
-#include <gtest/gtest.h>
-#include <sled/exec/exec.h>
-
-struct cout_receiver {
-    template<typename T>
-    void SetValue(T &&val)
-    {
-        // 这个receiver什么都不干，只对收集到的结果输出
-        std::cout << "Result: " << val << '\n';
-    }
-
-    void SetError(std::exception_ptr err) { std::terminate(); }
-
-    void SetStopped() { std::terminate(); }
-};
-
-TEST(Just, basic)
-{
-    sled::Just(42).Connect(cout_receiver{}).Start();
-    sled::Just(11).Connect(cout_receiver{}).Start();
-}
-
-TEST(Then, basic)
-{
-    auto s1 = sled::Just(42);
-    auto s2 = sled::Then(s1, [](int x) { return x + 1; });
-    auto s3 = sled::Then(s2, [](int x) { return x + 1; });
-    auto s4 = sled::Then(s3, [](int x) { return x + 1; });
-    s4.Connect(cout_receiver{}).Start();
-}
-
-TEST(SyncWait, basic)
-{
-    auto s1 = sled::Just(42);
-    auto s2 = sled::Then(s1, [](int x) { return x + 1; });
-    auto s3 = sled::Then(s2, [](int x) { return x + 1; });
-    auto s4 = sled::Then(s3, [](int x) { return x + 1; });
-    auto s5 = sled::SyncWait(s4).value();
-    std::cout << "Result: " << s5 << '\n';
-}
--- a/src/sled/filesystem/path_test.cc
+++ b/src/sled/filesystem/path_test.cc
@ -1,23 +1,22 @@
-#include <gtest/gtest.h>
 #include <sled/filesystem/path.h>

-TEST(Path, TestCurrent)
+TEST_SUITE("Path")
 {
-    sled::Path path = sled::Path::Current();
-    std::string str = path.ToString();
-    EXPECT_FALSE(str.empty());
-}
+    TEST_CASE("Current Directory")
+    {
+        sled::Path path = sled::Path::Current();
+        CHECK_FALSE(path.ToString().empty());
+    }

-TEST(Path, TestHome)
-{
-    sled::Path path = sled::Path::Home();
-    std::string str = path.ToString();
-    EXPECT_FALSE(str.empty());
-}
+    TEST_CASE("Home")
+    {
+        sled::Path path = sled::Path::Home();
+        CHECK_FALSE(path.ToString().empty());
+    }

-TEST(Path, TestTempDir)
-{
-    sled::Path path = sled::Path::TempDir();
-    std::string str = path.ToString();
-    EXPECT_FALSE(str.empty());
+    TEST_CASE("Temparory Directory")
+    {
+        sled::Path path = sled::Path::TempDir();
+        CHECK_FALSE(path.ToString().empty());
+    }
 }
--- a/src/sled/futures/detail/just_test.cc
+++ b/src/sled/futures/detail/just_test.cc
@ -1,4 +1,3 @@
-#include <gtest/gtest.h>
 #include <sled/futures/detail/just.h>

 TEST(Just, basic) { auto s1 = sled::detail::Just(42); }
--- a/src/sled/log/fmt_test.cc
+++ b/src/sled/log/fmt_test.cc
@ -1,44 +1,43 @@
-#include <gtest/gtest.h>
 #include <sled/log/log.h>

-TEST(format, enum)
+TEST_SUITE("fmt::format")
 {
-    enum EnumType {
-        kOne = 1,
-        kTwo = 2,
-        kThree = 3,
+
+    TEST_CASE("enum")
+    {
+        enum EnumType {
+            kOne   = 1,
+            kTwo   = 2,
+            kThree = 3,
+        };
+
+        std::stringstream ss;
+        ss << kOne;
+
+        CHECK_EQ(ss.str(), "1");
+        CHECK_EQ(fmt::format("{}{}{}", kOne, kTwo, kThree), "123");
+    }
+
+    TEST_CASE("neg_enum")
+    {
+        enum EnumType {
+            kOne   = -1,
+            kTwo   = -2,
+            kThree = -3,
+        };
+
+        CHECK_EQ(fmt::format("{}{}{}", kOne, kTwo, kThree), "-1-2-3");
+    }
+
+    struct Streamable {
+        int value;
    };

-    std::stringstream ss;
-    ss << kOne;
+    std::ostream &operator<<(std::ostream &os, const Streamable &s) { return os << s.value; }

-    EXPECT_EQ(ss.str(), "1");
-    EXPECT_EQ(fmt::format("{}{}{}", kOne, kTwo, kThree), "123");
-}
-
-TEST(format, neg_enum)
-{
-    enum EnumType {
-        kOne = -1,
-        kTwo = -2,
-        kThree = -3,
-    };
-
-    EXPECT_EQ(fmt::format("{}{}{}", kOne, kTwo, kThree), "-1-2-3");
-}
-
-struct Streamable {
-    int value;
-};
-
-std::ostream &
-operator<<(std::ostream &os, const Streamable &s)
-{
-    return os << s.value;
-}
-
-TEST(format, streamable)
-{
-    Streamable s{42};
-    EXPECT_EQ(fmt::format("{}", s), "42");
+    TEST_CASE("streamable")
+    {
+        Streamable s{42};
+        CHECK_EQ(fmt::format("{}", s), "42");
+    }
 }
--- a/src/sled/log/log.h
+++ b/src/sled/log/log.h
@ -105,8 +105,8 @@ void Log(LogLevel level, const char *tag, const char *fmt, const char *file_name
 #define LOGE_IF(cond, tag, fmt, ...) SLOG_IF(cond, sled::LogLevel::kError, tag, fmt, __VA_ARGS__)
 #define LOGF_IF(cond, tag, fmt, ...) SLOG_IF(cond, sled::LogLevel::kFatal, tag, fmt, __VA_ARGS__)

-#define CHECK(cond, fmt, ...) SLOG_ASSERT(cond, "DCHECK", fmt, ##__VA_ARGS__)
-#define DCHECK(cond, fmt, ...) SLOG_ASSERT(cond, "DCHECK", fmt, ##__VA_ARGS__)
+#define SLED_CHECK(cond, fmt, ...) SLOG_ASSERT(cond, "DCHECK", fmt, ##__VA_ARGS__)
+#define SLED_DCHECK(cond, fmt, ...) SLOG_ASSERT(cond, "DCHECK", fmt, ##__VA_ARGS__)

 #define LOGV(tag, fmt, ...) SLOG(sled::LogLevel::kTrace, tag, fmt, ##__VA_ARGS__)
 #define LOGD(tag, fmt, ...) SLOG(sled::LogLevel::kDebug, tag, fmt, ##__VA_ARGS__)
--- a/src/sled/rx_test.cc
+++ b/src/sled/rx_test.cc
@ -1,15 +1,17 @@
-#include <gtest/gtest.h>
 #include <sled/rx.h>

-TEST(RX, interval)
+TEST_SUITE("RxCpp")
 {
-    // 2 + 4 + 6 = 12
-    sled::observable<>::interval(std::chrono::milliseconds(300))
-        .subscribe_on(rxcpp::synchronize_new_thread())
-        .observe_on(rxcpp::observe_on_new_thread())
-        .map([](long value) { return value * 2; })
-        .take(3)
-        .reduce(0, [](int acc, int value) { return acc + value; })
-        .as_blocking()
-        .subscribe([=](long counter) { EXPECT_EQ(counter, 12); }, []() {});
+    TEST_CASE("interval")
+    {
+        // 2 + 4 + 6 = 12
+        sled::observable<>::interval(std::chrono::milliseconds(100))
+            .subscribe_on(rxcpp::synchronize_new_thread())
+            .observe_on(rxcpp::observe_on_new_thread())
+            .map([](long value) { return value * 2; })
+            .take(3)
+            .reduce(0, [](int acc, int value) { return acc + value; })
+            .as_blocking()
+            .subscribe([=](long counter) { CHECK_EQ(counter, 12); }, []() {});
+    }
 }
--- a/src/sled/sled.h
+++ b/src/sled/sled.h
@ -85,4 +85,7 @@ namespace async {}
 #include "sled/system_time.h"
 #include "sled/time_utils.h"
 #include "sled/variant.h"
+
+// testing
+#include "sled/testing/test.h"
 #endif//  SLED_SLED_H
--- a/src/sled/status_or_test.cc
+++ b/src/sled/status_or_test.cc
@ -1,23 +1,25 @@
-#include <gtest/gtest.h>
 #include <sled/log/log.h>
 #include <sled/status_or.h>

-TEST(StatusOr, TestStatusOr)
+TEST_SUITE("StatusOr")
 {
-    sled::StatusOr<int> so;
-    EXPECT_FALSE(so.ok());
-    so = sled::StatusOr<int>(1);
-    EXPECT_TRUE(so.ok());
-    EXPECT_EQ(so.value(), 1);
-    EXPECT_EQ(so.status().code(), sled::StatusCode::kOk);
-}
+    TEST_CASE("StatusOr")
+    {
+        sled::StatusOr<int> so;
+        CHECK_FALSE(so.ok());
+        so = sled::StatusOr<int>(1);
+        CHECK(so.ok());
+        CHECK_EQ(so.value(), 1);
+        CHECK_EQ(so.status().code(), sled::StatusCode::kOk);
+    }

-TEST(StatusOr, make_status_or)
-{
-    auto from_raw_str = sled::MakeStatusOr("hello");
-    auto from_string  = sled::MakeStatusOr(std::string("world"));
-    EXPECT_TRUE(from_raw_str.ok());
-    EXPECT_TRUE(from_string.ok());
-    EXPECT_EQ(from_raw_str.value(), "hello");
-    EXPECT_EQ(from_string.value(), "world");
+    TEST_CASE("MakeStatusOr")
+    {
+        auto from_raw_str = sled::MakeStatusOr("hello");
+        auto from_string  = sled::MakeStatusOr(std::string("world"));
+        CHECK(from_raw_str.ok());
+        CHECK(from_string.ok());
+        CHECK_EQ(from_raw_str.value(), "hello");
+        CHECK_EQ(from_string.value(), "world");
+    }
 }
--- a/src/sled/status_test.cc
+++ b/src/sled/status_test.cc
@ -1,9 +1,11 @@
-#include <gtest/gtest.h>
 #include <sled/log/log.h>
 #include <sled/status.h>

-TEST(Status, format)
+TEST_SUITE("Status")
 {
-    auto status = sled::Status(sled::StatusCode::kOk, "");
-    EXPECT_EQ(fmt::format("{}", status), "OK");
+    TEST_CASE("format")
+    {
+        auto status = sled::Status(sled::StatusCode::kOk, "");
+        CHECK_EQ(fmt::format("{}", status), "OK");
+    }
 }
--- a/src/sled/strings/base64_test.cc
+++ b/src/sled/strings/base64_test.cc
@ -1,47 +1,50 @@
-#include <gtest/gtest.h>
 #include <sled/strings/base64.h>

-TEST(Base64, EncodedLength)
+TEST_SUITE("Base64")
 {
-    EXPECT_EQ(0, sled::Base64::EncodedLength(0));
-    EXPECT_EQ(4, sled::Base64::EncodedLength(1));
-    EXPECT_EQ(4, sled::Base64::EncodedLength(2));
-    EXPECT_EQ(4, sled::Base64::EncodedLength(3));
-    EXPECT_EQ(8, sled::Base64::EncodedLength(4));
-    EXPECT_EQ(8, sled::Base64::EncodedLength(5));
-    EXPECT_EQ(8, sled::Base64::EncodedLength(6));
-    EXPECT_EQ(12, sled::Base64::EncodedLength(7));
-}

-TEST(Base64, DecodedLength)
-{
-    EXPECT_EQ(0, sled::Base64::DecodedLength(nullptr, 0));
-    EXPECT_EQ(1, sled::Base64::DecodedLength(nullptr, 1));
-    EXPECT_EQ(2, sled::Base64::DecodedLength(nullptr, 2));
-    EXPECT_EQ(2, sled::Base64::DecodedLength(nullptr, 3));
-    EXPECT_EQ(3, sled::Base64::DecodedLength(nullptr, 4));
+    TEST_CASE("EncodedLength")
+    {
+        CHECK_EQ(0, sled::Base64::EncodedLength(0));
+        CHECK_EQ(4, sled::Base64::EncodedLength(1));
+        CHECK_EQ(4, sled::Base64::EncodedLength(2));
+        CHECK_EQ(4, sled::Base64::EncodedLength(3));
+        CHECK_EQ(8, sled::Base64::EncodedLength(4));
+        CHECK_EQ(8, sled::Base64::EncodedLength(5));
+        CHECK_EQ(8, sled::Base64::EncodedLength(6));
+        CHECK_EQ(12, sled::Base64::EncodedLength(7));
+    }

-    EXPECT_EQ(0, sled::Base64::DecodedLength("", 0));
-}
+    TEST_CASE("DecodedLength")
+    {
+        CHECK_EQ(0, sled::Base64::DecodedLength(nullptr, 0));
+        CHECK_EQ(1, sled::Base64::DecodedLength(nullptr, 1));
+        CHECK_EQ(2, sled::Base64::DecodedLength(nullptr, 2));
+        CHECK_EQ(2, sled::Base64::DecodedLength(nullptr, 3));
+        CHECK_EQ(3, sled::Base64::DecodedLength(nullptr, 4));

-TEST(Base64, Encode)
-{
-    EXPECT_EQ("aGVsbG8gd29ybGQK", sled::Base64::Encode("hello world\n"));
-    EXPECT_EQ("U2VuZCByZWluZm9yY2VtZW50cwo=", sled::Base64::Encode("Send reinforcements\n"));
-    EXPECT_EQ("", sled::Base64::Encode(""));
-    EXPECT_EQ("IA==", sled::Base64::Encode(" "));
-    EXPECT_EQ("AA==", sled::Base64::Encode(std::string("\0", 1)));
-    EXPECT_EQ("AAA=", sled::Base64::Encode(std::string("\0\0", 2)));
-    EXPECT_EQ("AAAA", sled::Base64::Encode(std::string("\0\0\0", 3)));
-}
+        CHECK_EQ(0, sled::Base64::DecodedLength("", 0));
+    }

-TEST(Base64, Decode)
-{
-    EXPECT_EQ("hello world\n", sled::Base64::Decode("aGVsbG8gd29ybGQK").value());
-    EXPECT_EQ("Send reinforcements\n", sled::Base64::Decode("U2VuZCByZWluZm9yY2VtZW50cwo=").value());
-    EXPECT_EQ("", sled::Base64::Decode("").value());
-    EXPECT_EQ(" ", sled::Base64::Decode("IA==").value());
-    EXPECT_EQ(std::string("\0", 1), sled::Base64::Decode("AA==").value());
-    EXPECT_EQ(std::string("\0\0", 2), sled::Base64::Decode("AAA=").value());
-    EXPECT_EQ(std::string("\0\0\0", 3), sled::Base64::Decode("AAAA").value());
+    TEST_CASE("Encode")
+    {
+        CHECK_EQ("aGVsbG8gd29ybGQK", sled::Base64::Encode("hello world\n"));
+        CHECK_EQ("U2VuZCByZWluZm9yY2VtZW50cwo=", sled::Base64::Encode("Send reinforcements\n"));
+        CHECK_EQ("", sled::Base64::Encode(""));
+        CHECK_EQ("IA==", sled::Base64::Encode(" "));
+        CHECK_EQ("AA==", sled::Base64::Encode(std::string("\0", 1)));
+        CHECK_EQ("AAA=", sled::Base64::Encode(std::string("\0\0", 2)));
+        CHECK_EQ("AAAA", sled::Base64::Encode(std::string("\0\0\0", 3)));
+    }
+
+    TEST_CASE("Decode")
+    {
+        CHECK_EQ("hello world\n", sled::Base64::Decode("aGVsbG8gd29ybGQK").value());
+        CHECK_EQ("Send reinforcements\n", sled::Base64::Decode("U2VuZCByZWluZm9yY2VtZW50cwo=").value());
+        CHECK_EQ("", sled::Base64::Decode("").value());
+        CHECK_EQ(" ", sled::Base64::Decode("IA==").value());
+        CHECK_EQ(std::string("\0", 1), sled::Base64::Decode("AA==").value());
+        CHECK_EQ(std::string("\0\0", 2), sled::Base64::Decode("AAA=").value());
+        CHECK_EQ(std::string("\0\0\0", 3), sled::Base64::Decode("AAAA").value());
+    }
 }
--- a/src/sled/strings/utils_test.cc
+++ b/src/sled/strings/utils_test.cc
@ -1,95 +1,98 @@
-#include <gtest/gtest.h>
 #include <sled/strings/utils.h>

-TEST(ToLower, Char)
+TEST_SUITE("String Utils")
 {
-    for (char c = 'A'; c <= 'Z'; ++c) { EXPECT_EQ(sled::ToLower(c), c + 32) << c; }
-    for (char c = 'a'; c <= 'z'; ++c) { EXPECT_EQ(sled::ToLower(c), c) << c; }
-    EXPECT_EQ(sled::ToLower(' '), ' ');
-    EXPECT_EQ(sled::ToLower('\0'), '\0');
-}

-TEST(ToUpper, Char)
-{
-    for (char c = 'A'; c <= 'Z'; ++c) { EXPECT_EQ(sled::ToUpper(c), c) << c; }
-    for (char c = 'a'; c <= 'z'; ++c) { EXPECT_EQ(sled::ToUpper(c), c - 32) << c; }
-    EXPECT_EQ(sled::ToUpper(' '), ' ');
-    EXPECT_EQ(sled::ToUpper('\0'), '\0');
-}
+    TEST_CASE("Char")
+    {
+        for (char c = 'A'; c <= 'Z'; ++c) { CHECK_EQ(sled::ToLower(c), c + 32); }
+        for (char c = 'a'; c <= 'z'; ++c) { CHECK_EQ(sled::ToLower(c), c); }
+        CHECK_EQ(sled::ToLower(' '), ' ');
+        CHECK_EQ(sled::ToLower('\0'), '\0');
+    }

-TEST(ToLower, String)
-{
-    EXPECT_EQ(sled::ToLower("Hello World"), "hello world");
-    EXPECT_EQ(sled::ToLower("HELLO WORLD"), "hello world");
-    EXPECT_EQ(sled::ToLower("hello world"), "hello world");
-    EXPECT_EQ(sled::ToLower(" "), " ");
-    EXPECT_EQ(sled::ToLower(""), "");
-}
+    TEST_CASE("Char")
+    {
+        for (char c = 'A'; c <= 'Z'; ++c) { CHECK_EQ(sled::ToUpper(c), c); }
+        for (char c = 'a'; c <= 'z'; ++c) { CHECK_EQ(sled::ToUpper(c), c - 32); }
+        CHECK_EQ(sled::ToUpper(' '), ' ');
+        CHECK_EQ(sled::ToUpper('\0'), '\0');
+    }

-TEST(ToUpper, String)
-{
-    EXPECT_EQ(sled::ToUpper("Hello World"), "HELLO WORLD");
-    EXPECT_EQ(sled::ToUpper("HELLO WORLD"), "HELLO WORLD");
-    EXPECT_EQ(sled::ToUpper("hello world"), "HELLO WORLD");
-    EXPECT_EQ(sled::ToUpper(" "), " ");
-    EXPECT_EQ(sled::ToUpper(""), "");
-}
+    TEST_CASE("String")
+    {
+        CHECK_EQ(sled::ToLower("Hello World"), "hello world");
+        CHECK_EQ(sled::ToLower("HELLO WORLD"), "hello world");
+        CHECK_EQ(sled::ToLower("hello world"), "hello world");
+        CHECK_EQ(sled::ToLower(" "), " ");
+        CHECK_EQ(sled::ToLower(""), "");
+    }

-TEST(StrJoin, Empty)
-{
-    EXPECT_EQ(sled::StrJoin({}, ","), "");
-    EXPECT_EQ(sled::StrJoin({}, ",", true), "");
-    EXPECT_EQ(sled::StrJoin({}, ",", false), "");
-}
+    TEST_CASE("String")
+    {
+        CHECK_EQ(sled::ToUpper("Hello World"), "HELLO WORLD");
+        CHECK_EQ(sled::ToUpper("HELLO WORLD"), "HELLO WORLD");
+        CHECK_EQ(sled::ToUpper("hello world"), "HELLO WORLD");
+        CHECK_EQ(sled::ToUpper(" "), " ");
+        CHECK_EQ(sled::ToUpper(""), "");
+    }

-TEST(StrJoin, Delim)
-{
-    EXPECT_EQ(sled::StrJoin({"a", "b", "c"}, ","), "a,b,c");
-    EXPECT_EQ(sled::StrJoin({"a", "b", "c"}, ",", true), "a,b,c");
-    EXPECT_EQ(sled::StrJoin({"a", "b", "c"}, ",", false), "a,b,c");
-}
+    TEST_CASE("Empty")
+    {
+        CHECK_EQ(sled::StrJoin({}, ","), "");
+        CHECK_EQ(sled::StrJoin({}, ",", true), "");
+        CHECK_EQ(sled::StrJoin({}, ",", false), "");
+    }

-TEST(StrJoin, DelimSkipEmpty)
-{
-    EXPECT_EQ(sled::StrJoin({"a", "", "c"}, ","), "a,,c");
-    EXPECT_EQ(sled::StrJoin({"a", "", "c"}, ",", true), "a,c");
-    EXPECT_EQ(sled::StrJoin({"a", "", "c"}, ",", false), "a,,c");
-}
+    TEST_CASE("Delim")
+    {
+        CHECK_EQ(sled::StrJoin({"a", "b", "c"}, ","), "a,b,c");
+        CHECK_EQ(sled::StrJoin({"a", "b", "c"}, ",", true), "a,b,c");
+        CHECK_EQ(sled::StrJoin({"a", "b", "c"}, ",", false), "a,b,c");
+    }

-TEST(StrSplit, Empty)
-{
-    EXPECT_EQ(sled::StrSplit("", ","), std::vector<std::string>());
-    EXPECT_EQ(sled::StrSplit("", ",", true), std::vector<std::string>());
-    EXPECT_EQ(sled::StrSplit("", ",", false), std::vector<std::string>());
-}
+    TEST_CASE("DelimSkipEmpty")
+    {
+        CHECK_EQ(sled::StrJoin({"a", "", "c"}, ","), "a,,c");
+        CHECK_EQ(sled::StrJoin({"a", "", "c"}, ",", true), "a,c");
+        CHECK_EQ(sled::StrJoin({"a", "", "c"}, ",", false), "a,,c");
+    }

-TEST(StrSplit, Delim)
-{
-    // single delim
-    EXPECT_EQ(sled::StrSplit("a,b,c", ","), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b,c", ",", false), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b,c,", ","), std::vector<std::string>({"a", "b", "c", ""}));
-    EXPECT_EQ(sled::StrSplit("a,b,c,", ",", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b,c,", ",", false), std::vector<std::string>({"a", "b", "c", ""}));
-    EXPECT_EQ(sled::StrSplit(",a,b,c", ","), std::vector<std::string>({"", "a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit(",a,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit(",a,b,c", ",", false), std::vector<std::string>({"", "a", "b", "c"}));
+    TEST_CASE("Empty")
+    {
+        CHECK_EQ(sled::StrSplit("", ","), std::vector<std::string>());
+        CHECK_EQ(sled::StrSplit("", ",", true), std::vector<std::string>());
+        CHECK_EQ(sled::StrSplit("", ",", false), std::vector<std::string>());
+    }

-    // multi delim
-    EXPECT_EQ(sled::StrSplit(",,a,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit(",,a,b,c", ",", false), std::vector<std::string>({"", "", "a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b,c,,", ",", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b,c,,", ",", false), std::vector<std::string>({"a", "b", "c", "", ""}));
-    EXPECT_EQ(sled::StrSplit("a,,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,,b,c", ",", false), std::vector<std::string>({"a", "", "b", "c"}));
-}
+    TEST_CASE("Delim")
+    {
+        // single delim
+        CHECK_EQ(sled::StrSplit("a,b,c", ","), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b,c", ",", false), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b,c,", ","), std::vector<std::string>({"a", "b", "c", ""}));
+        CHECK_EQ(sled::StrSplit("a,b,c,", ",", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b,c,", ",", false), std::vector<std::string>({"a", "b", "c", ""}));
+        CHECK_EQ(sled::StrSplit(",a,b,c", ","), std::vector<std::string>({"", "a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit(",a,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit(",a,b,c", ",", false), std::vector<std::string>({"", "a", "b", "c"}));

-TEST(StrSplit, MultiDelim)
-{
-    EXPECT_EQ(sled::StrSplit("a,b;c", ",;", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b;c", ",;", false), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b;c,", ",;", true), std::vector<std::string>({"a", "b", "c"}));
-    EXPECT_EQ(sled::StrSplit("a,b;c,", ",;", false), std::vector<std::string>({"a", "b", "c", ""}));
-    EXPECT_EQ(sled::StrSplit("a,b;c,", ";,", true), std::vector<std::string>({"a", "b", "c"}));
+        // multi delim
+        CHECK_EQ(sled::StrSplit(",,a,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit(",,a,b,c", ",", false), std::vector<std::string>({"", "", "a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b,c,,", ",", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b,c,,", ",", false), std::vector<std::string>({"a", "b", "c", "", ""}));
+        CHECK_EQ(sled::StrSplit("a,,b,c", ",", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,,b,c", ",", false), std::vector<std::string>({"a", "", "b", "c"}));
+    }
+
+    TEST_CASE("MultiDelim")
+    {
+        CHECK_EQ(sled::StrSplit("a,b;c", ",;", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b;c", ",;", false), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b;c,", ",;", true), std::vector<std::string>({"a", "b", "c"}));
+        CHECK_EQ(sled::StrSplit("a,b;c,", ",;", false), std::vector<std::string>({"a", "b", "c", ""}));
+        CHECK_EQ(sled::StrSplit("a,b;c,", ";,", true), std::vector<std::string>({"a", "b", "c"}));
+    }
 }
--- a/src/sled/synchronization/sequence_checker.h
+++ b/src/sled/synchronization/sequence_checker.h
@ -45,7 +45,7 @@ public:
 };

 #define SLED_RUN_ON(x) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x))
-#define SLED_DCHECK_RUN_ON(x) DCHECK((x)->IsCurrent(), (x)->ExpectationToString())
+#define SLED_DCHECK_RUN_ON(x) SLED_DCHECK((x)->IsCurrent(), (x)->ExpectationToString())

 }// namespace sled

--- a/src/sled/synchronization/sequence_checker_test.cc
+++ b/src/sled/synchronization/sequence_checker_test.cc
@ -1,5 +1,5 @@
-#include <gtest/gtest.h>
 #include <sled/log/log.h>
+#include <sled/make_unique.h>
 #include <sled/synchronization/event.h>
 #include <sled/synchronization/sequence_checker.h>
 #include <sled/system/thread.h>
@ -13,56 +13,60 @@ RunOnDifferentThread(std::function<void()> func)
        thread_has_run_event.Set();
    });
    thread.detach();
-    EXPECT_TRUE(thread_has_run_event.Wait(sled::TimeDelta::Seconds(1)));
+    CHECK(thread_has_run_event.Wait(sled::TimeDelta::Seconds(1)));
 }

-TEST(SequenceChecker, CallsAllowedOnSameThread)
+TEST_SUITE("SequenceChecker")
 {
-    sled::SequenceChecker sequence_checker;
-    EXPECT_TRUE(sequence_checker.IsCurrent());
-}

-TEST(SequenceChecker, DestructorAllowedOnDifferentThread)
-{
-    auto sequence_checker = std::make_unique<sled::SequenceChecker>();
-    RunOnDifferentThread([&] { sequence_checker.reset(); });
-}
+    TEST_CASE("CallsAllowedOnSameThread")
+    {
+        sled::SequenceChecker sequence_checker;
+        CHECK(sequence_checker.IsCurrent());
+    }

-TEST(SequenceChecker, Detach)
-{
-    sled::SequenceChecker sequence_checker;
-    sequence_checker.Detach();
+    TEST_CASE("DestructorAllowedOnDifferentThread")
+    {
+        auto sequence_checker = sled::MakeUnique<sled::SequenceChecker>();
+        RunOnDifferentThread([&] { sequence_checker.reset(); });
+    }

-    RunOnDifferentThread([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
-}
-
-TEST(SequenceChecker, OnlyCurrentOnOneThread)
-{
-    sled::SequenceChecker sequence_checker(sled::SequenceChecker::kDetached);
-    RunOnDifferentThread([&] {
-        EXPECT_TRUE(sequence_checker.IsCurrent());
-        RunOnDifferentThread([&] { EXPECT_FALSE(sequence_checker.IsCurrent()); });
-        EXPECT_TRUE(sequence_checker.IsCurrent());
-    });
-}
-
-TEST(SequenceChecker, DeatchFromThreadAndUseOnTaskQueue)
-{
-    auto queue = sled::Thread::Create();
-    ASSERT_TRUE(queue->Start());
-    sled::SequenceChecker sequence_checker;
-    sequence_checker.Detach();
-    queue->BlockingCall([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
-}
-
-TEST(SequenceChecker, DetachFromTaskQueueAndUseOnThread)
-{
-    auto queue = sled::Thread::Create();
-    ASSERT_TRUE(queue->Start());
-    queue->BlockingCall([&] {
+    TEST_CASE("Detach")
+    {
        sled::SequenceChecker sequence_checker;
        sequence_checker.Detach();
-        RunOnDifferentThread([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); });
-    });
-    queue->Stop();
+
+        RunOnDifferentThread([&] { CHECK(sequence_checker.IsCurrent()); });
+    }
+
+    TEST_CASE("OnlyCurrentOnOneThread")
+    {
+        sled::SequenceChecker sequence_checker(sled::SequenceChecker::kDetached);
+        RunOnDifferentThread([&] {
+            CHECK(sequence_checker.IsCurrent());
+            RunOnDifferentThread([&] { CHECK_FALSE(sequence_checker.IsCurrent()); });
+            CHECK(sequence_checker.IsCurrent());
+        });
+    }
+
+    TEST_CASE("DeatchFromThreadAndUseOnTaskQueue")
+    {
+        auto queue = sled::Thread::Create();
+        REQUIRE(queue->Start());
+        sled::SequenceChecker sequence_checker;
+        sequence_checker.Detach();
+        queue->BlockingCall([&] { CHECK(sequence_checker.IsCurrent()); });
+    }
+
+    TEST_CASE("DetachFromTaskQueueAndUseOnThread")
+    {
+        auto queue = sled::Thread::Create();
+        REQUIRE(queue->Start());
+        queue->BlockingCall([&] {
+            sled::SequenceChecker sequence_checker;
+            sequence_checker.Detach();
+            RunOnDifferentThread([&] { CHECK(sequence_checker.IsCurrent()); });
+        });
+        queue->Stop();
+    }
 }
--- a/src/sled/system/fiber/fiber_test.cc
+++ b/src/sled/system/fiber/fiber_test.cc
@ -1,25 +1,28 @@
-#include <gtest/gtest.h>
 #include <sled/system/fiber/scheduler.h>
 #include <sled/system/fiber/wait_group.h>

-TEST(FiberScheduler, TestFiberScheduler)
+TEST_SUITE("Fiber")
 {
-    sled::Scheduler scheduler(sled::Scheduler::Config::allCores());
-    scheduler.bind();
-    defer(scheduler.unbind());

-    std::atomic<int> counter = {0};
-    sled::WaitGroup wg(1);
-    sled::WaitGroup wg2(1000);
-    for (int i = 0; i < 1000; i++) {
-        sled::Schedule([&] {
-            wg.Wait();
-            wg2.Done();
-            counter++;
-        });
+    TEST_CASE("FiberScheduler")
+    {
+        sled::Scheduler scheduler(sled::Scheduler::Config::allCores());
+        scheduler.bind();
+        defer(scheduler.unbind());
+
+        std::atomic<int> counter = {0};
+        sled::WaitGroup wg(1);
+        sled::WaitGroup wg2(1000);
+        for (int i = 0; i < 1000; i++) {
+            sled::Schedule([&] {
+                wg.Wait();
+                wg2.Done();
+                counter++;
+            });
+        }
+
+        sled::Schedule([=] { wg.Done(); });
+        wg2.Wait();
+        CHECK_EQ(counter.load(), 1000);
    }
-
-    sled::Schedule([=] { wg.Done(); });
-    wg2.Wait();
-    ASSERT_EQ(counter.load(), 1000);
 }
--- a/src/sled/system/thread_pool_test.cc
+++ b/src/sled/system/thread_pool_test.cc
@ -1,4 +1,3 @@
-#include <gtest/gtest.h>
 #include <random>
 #include <sled/system/thread_pool.h>

@ -38,28 +37,26 @@ multiply_return(const int a, const int b)
    return res;
 }

-class ThreadPoolTest : public ::testing::Test {
-public:
-    void SetUp() override { tp = new sled::ThreadPool(); }
-
-    void TearDown() override { delete tp; }
-
-    sled::ThreadPool *tp;
-};
-
-TEST_F(ThreadPoolTest, Output)
+TEST_CASE("ThreadPool")
 {
-    for (int i = 0; i < 100; ++i) {
-        int out;
-        tp->submit(multiply_output, std::ref(out), i, i).get();
-        EXPECT_EQ(out, i * i);
-    }
-}
+    sled::ThreadPool *tp = new sled::ThreadPool();
+    REQUIRE_NE(tp, nullptr);

-TEST_F(ThreadPoolTest, Return)
-{
-    for (int i = 0; i < 100; ++i) {
-        auto f = tp->submit(multiply_return, i, i);
-        EXPECT_EQ(f.get(), i * i);
+    SUBCASE("Output")
+    {
+        for (int i = 0; i < 100; ++i) {
+            int out;
+            tp->submit(multiply_output, std::ref(out), i, i).get();
+            CHECK_EQ(out, i * i);
+        }
    }
+    SUBCASE("Return")
+    {
+        for (int i = 0; i < 100; ++i) {
+            auto f = tp->submit(multiply_return, i, i);
+            CHECK_EQ(f.get(), i * i);
+        }
+    }
+
+    delete tp;
 }
--- a/src/sled/testing/doctest.h
+++ b/src/sled/testing/doctest.h
--- a/src/sled/testing/fakeit.h
+++ b/src/sled/testing/fakeit.h
--- a/src/sled/testing/test.cc
+++ b/src/sled/testing/test.cc
@ -0,0 +1,3 @@
+#define DOCTEST_CONFIG_IMPLEMENT
+#define SLED_TESTING_TEST_H
+#include "sled/testing/doctest.h"
--- a/src/sled/testing/test.h
+++ b/src/sled/testing/test.h
@ -0,0 +1,7 @@
+#ifndef SLED_TESTING_TEST_H
+#define SLED_TESTING_TEST_H
+
+#include "sled/testing/doctest.h"
+#include "sled/testing/fakeit.h"
+
+#endif//  SLED_TESTING_TEST_H
--- a/src/sled/testing/test_main.cc
+++ b/src/sled/testing/test_main.cc
@ -0,0 +1,8 @@
+#define SLED_TESTING_TEST_H
+#include "sled/testing/doctest.h"
+
+int
+main(int argc, char *argv[])
+{
+    return doctest::Context(argc, argv).run();
+}
--- a/src/sled/timer/task_queue_timeout.cc
+++ b/src/sled/timer/task_queue_timeout.cc
@ -23,7 +23,7 @@ TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms, Timeout
    SLED_DCHECK_RUN_ON(&parent_.thread_checker_);
    ASSERT(timeout_expiration_ == std::numeric_limits<TimeMs>::max(), "");
    timeout_expiration_ = parent_.get_time_() + duration_ms;
-    timeout_id_ = timeout_id;
+    timeout_id_         = timeout_id;

    if (timeout_expiration_ >= posted_task_expiration_) { return; }
    if (posted_task_expiration_ != std::numeric_limits<TimeMs>::max()) {
@ -35,7 +35,7 @@ TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms, Timeout
    }

    posted_task_expiration_ = timeout_expiration_;
-    auto safety_flag = safety_flag_;
+    auto safety_flag        = safety_flag_;

    parent_.task_queue_.PostDelayedTaskWithPrecision(
        precision_,
@ -43,16 +43,16 @@ TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms, Timeout
                 [timeout_id, this]() {
                     LOGV("timer", "Timeout expired: {}", timeout_id);
                     SLED_DCHECK_RUN_ON(&parent_.thread_checker_);
-                     DCHECK(posted_task_expiration_ != std::numeric_limits<TimeMs>::max(), "");
+                     SLED_DCHECK(posted_task_expiration_ != std::numeric_limits<TimeMs>::max(), "");
                     posted_task_expiration_ = std::numeric_limits<TimeMs>::max();

                     if (timeout_expiration_ == std::numeric_limits<TimeMs>::max()) {
                         // cancelled timer
                         // do nothing
                     } else {
-                         const TimeMs now = parent_.get_time_();
+                         const TimeMs now           = parent_.get_time_();
                         const DurationMs remaining = timeout_expiration_ - now;
-                         bool is_expired = timeout_expiration_ <= now;
+                         bool is_expired            = timeout_expiration_ <= now;

                         timeout_expiration_ = std::numeric_limits<TimeMs>::max();

--- a/src/sled/uri_test.cc
+++ b/src/sled/uri_test.cc
@ -1,14 +1,13 @@
-#include <gtest/gtest.h>
 #include <sled/uri.h>

-TEST(URI, Absolute)
+TEST_CASE("")
 {
    sled::URI uri("http://example.com:1234/dir1/dir2/file?a=1#anchor");
-    EXPECT_EQ(uri.scheme(), "http");
-    EXPECT_EQ(uri.host(), "example.com");
-    EXPECT_EQ(uri.port(), 1234);
-    EXPECT_EQ(uri.path(), "/dir1/dir2/file");
-    EXPECT_EQ(uri.query().size(), 1);
-    EXPECT_EQ(uri.query()["a"], "1");
-    EXPECT_EQ(uri.anchor(), "anchor");
+    CHECK_EQ(uri.scheme(), "http");
+    CHECK_EQ(uri.host(), "example.com");
+    CHECK_EQ(uri.port(), 1234);
+    CHECK_EQ(uri.path(), "/dir1/dir2/file");
+    CHECK_EQ(uri.query().size(), 1);
+    CHECK_EQ(uri.query()["a"], "1");
+    CHECK_EQ(uri.anchor(), "anchor");
 }