Commit 7c158276 authored by tqcq's avatar tqcq
Browse files

feat replace gtest by doctest

parent c7fe469c

CMakeLists.txt

+15 −13
Original line number Diff line number Diff line
@@ -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)

src/sled/any_test.cc

+43 −41
Original line number Diff line number Diff line 
#include <gtest/gtest.h>

#include <sled/any.h>

#include <sled/log/log.h>



TEST(Any, Assign)

TEST_SUITE("Any")

{

    TEST_CASE("Assign")

    {

        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);

        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)

    TEST_CASE("std_swap")

    {

        sled::Any a;

        sled::Any b = 2;

    EXPECT_FALSE(a.HasValue());

    EXPECT_TRUE(b.HasValue());

        CHECK_FALSE(a.HasValue());

        CHECK(b.HasValue());

        std::swap(a, b);

    EXPECT_TRUE(a.HasValue());

    EXPECT_FALSE(b.HasValue());

    EXPECT_EQ(a.Cast<int>(), 2);

        CHECK(a.HasValue());

        CHECK_FALSE(b.HasValue());

        CHECK_EQ(a.Cast<int>(), 2);

    }



TEST(Any, custom_swap)

    TEST_CASE("custom_swap")

    {

        sled::Any a;

        sled::Any b = 2;

    EXPECT_FALSE(a.HasValue());

    EXPECT_TRUE(b.HasValue());

        CHECK_FALSE(a.HasValue());

        CHECK(b.HasValue());

        a.swap(b);

    EXPECT_TRUE(a.HasValue());

    EXPECT_FALSE(b.HasValue());

    EXPECT_EQ(a.Cast<int>(), 2);

        CHECK(a.HasValue());

        CHECK_FALSE(b.HasValue());

        CHECK_EQ(a.Cast<int>(), 2);

    }

}

src/sled/async/async_test.cc

+24 −22
Original line number Diff line number Diff line 
#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")

{

    TEST_CASE("task")

    {

        auto task1 = async::spawn([] { return 42; }).then([](int value) { return value * 3; }).then([](int value) {

        EXPECT_EQ(value, 126);

            CHECK_EQ(value, 126);

            return value;

        });

        task1.wait();

    EXPECT_EQ(126, task1.get());

        CHECK_EQ(126, task1.get());

    }



TEST(Async, parallel_for)

    TEST_CASE("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]);

            CHECK_FALSE(values[x]);

            values[x] = true;

        });

    for (int i = 0; i < count; i++) { EXPECT_TRUE(values[i]) << i; }

        for (int i = 0; i < count; i++) { CHECK(values[i]); }

    }



TEST(Async, parallel_reduce)

    TEST_CASE("parallel_reduce")

    {

        auto r = async::parallel_reduce(async::irange(1, 5), 0, [](int x, int y) { return x + y; });

    }

}

src/sled/cleanup_test.cc

+11 −9
Original line number Diff line number Diff line 
#include <gtest/gtest.h>

#include <sled/cleanup.h>

#include <sled/random.h>



TEST(Cleanup, TestCleanup)

TEST_SUITE("Cleanup")

{

    TEST_CASE("assign")

    {

        sled::Random rand(1314);

        for (int i = 0; i < 100; ++i) {
@@ -11,6 +12,7 @@ TEST(Cleanup, TestCleanup) 
            {

                sled::Cleanup<> c([=, &a]() { a = b; });

            }

        ASSERT_EQ(a, b);

            CHECK_EQ(a, b);

        }

    }

}

src/sled/debugging/demangle_test.cc

+58 −0
Original line number Diff line number Diff line 
#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]()");

    }

}