test_case_macros.hpp

#pragma once
 
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <string>
 
#include <gtest/gtest.h>
 
USERVER_NAMESPACE_BEGIN
 
namespace utest::impl {
 
class EnrichedTestBase {
public:
    virtual ~EnrichedTestBase() = default;
    virtual void SetUp() = 0;
    virtual void TearDown() = 0;
    virtual void TestBody() = 0;
 
    std::size_t GetThreadCount() const { return utest_thread_count_; }
    void SetThreadCount(std::size_t count) { utest_thread_count_ = count; }
 
private:
    std::size_t utest_thread_count_ = 1;
};
 
enum class DeathTestsEnabled : bool {};
 
// The work horse of the test suite. Takes a test class returned by 'factory'
// in a 'std::unique_ptr' and runs the usual test cycle (mimicking gtest),
// all in a coroutine environment.
void DoRunTest(std::size_t thread_count, DeathTestsEnabled, std::function<std::unique_ptr<EnrichedTestBase>()> factory);
 
void RunSetUpTestSuite(void (*set_up_test_suite)());
void RunTearDownTestSuite(void (*tear_down_test_suite)());
 
// Inherits from the user's fixture (or '::testing::Test') and provides some
// niceties to the test body ('GetThreadCount') while making the test methods
// public ('SetUp', 'TearDown'). The fixture is further inherited from
// (and "enriched") in inline-created test classes
// (IMPL_UTEST_HIDE_ENRICHED_FROM_IDE).
template <typename UserFixture>
// NOLINTNEXTLINE(fuchsia-multiple-inheritance)
class EnrichedFixture : public UserFixture, public EnrichedTestBase {
protected:
    void SetUp() override { return UserFixture::SetUp(); }
    void TearDown() override { return UserFixture::TearDown(); }
 
private:
    using EnrichedTestBase::SetThreadCount;
    using EnrichedTestBase::TestBody;
};
 
template <typename Base, typename UserFixture>
class WithStaticMethods : public Base {
public:
    static void SetUpTestSuite() { RunSetUpTestSuite(&UserFixture::SetUpTestSuite); }
 
    static void TearDownTestSuite() { RunTearDownTestSuite(&UserFixture::TearDownTestSuite); }
};
 
// 'TestLauncher' and 'TestLauncherParametric' take the enriched user's test
// class and run it in a coroutine environment via 'DoRunTest'.
template <typename UserFixture>
class TestLauncher : public WithStaticMethods<::testing::Test, UserFixture> {
public:
    // Called from UTEST_F, TYPED_UTEST and TYPED_UTEST_P macros
    template <typename EnrichedTest>
    static void RunTest(std::size_t thread_count, bool death_tests_enabled) {
        utest::impl::DoRunTest(thread_count, DeathTestsEnabled{death_tests_enabled}, [] {
            return std::make_unique<EnrichedTest>();
        });
    }
};
 
template <typename UserFixture>
class TestLauncherParametric
    : public WithStaticMethods<::testing::TestWithParam<typename UserFixture::ParamType>, UserFixture> {
public:
    // Called from the UTEST_P macro
    template <typename EnrichedTest>
    static void RunTest(std::size_t thread_count, bool death_tests_enabled) {
        using ParamType = typename UserFixture::ParamType;
        const auto& parameter = ::testing::TestWithParam<ParamType>::GetParam();
 
        // It seems impossible to seamlessly proxy 'ParamType' from the launcher to
        // the enriched fixture without using gtest internals.
        auto factory = std::make_unique<testing::internal::ParameterizedTestFactory<EnrichedTest>>(parameter);
 
        utest::impl::DoRunTest(thread_count, DeathTestsEnabled{death_tests_enabled}, [&] {
            return std::unique_ptr<EnrichedTest>{dynamic_cast<EnrichedTest*>(factory->CreateTest())};
        });
    }
};
 
template <template <typename> typename UserFixture, typename T>
using TestLauncherTyped = TestLauncher<UserFixture<T>>;
 
// For TYPED_TEST_SUITE and INSTANTIATE_TYPED_TEST_SUITE_P
struct DefaultNameGenerator final {
    template <typename T>
    static std::string GetName(int i) {
        return std::to_string(i);
    }
};
 
constexpr bool CheckTestSuiteNameSuffix(std::string_view str, std::string_view suffix) {
    return str.size() >= suffix.size() && str.substr(str.size() - suffix.size()) == suffix;
}
 
}  // namespace utest::impl
 
USERVER_NAMESPACE_END
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_NON_PARENTHESIZED(identifier) identifier
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_NAMESPACE_NAME(test_suite_name) test_suite_name##_##Utest
 
// Enriched fixtures are nested into IMPL_UTEST_HIDE_ENRICHED_FROM_IDE namespace
// so that IDEs don't find them and don't show in "Run a single Test".
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name) test_suite_name##_##test_name##_##Utest
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_USER_FIXTURE(test_suite_name) test_suite_name##_##UtestFixture
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_MAKE_USER_FIXTURE_ALIAS(test_suite_name)
    using IMPL_UTEST_USER_FIXTURE(test_suite_name) = IMPL_UTEST_NON_PARENTHESIZED(test_suite_name)
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_MAKE_USER_FIXTURE_ALIAS_TYPED(test_suite_name)
    template <typename UtestTypeParamImpl>
    using IMPL_UTEST_USER_FIXTURE(test_suite_name) = IMPL_UTEST_NON_PARENTHESIZED(test_suite_name)<UtestTypeParamImpl>
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_HIDE_USER_FIXTURE_BY_TEST_LAUNCHER(test_suite_name, test_launcher_template)
    using IMPL_UTEST_NON_PARENTHESIZED(test_suite_name) =
        IMPL_UTEST_NON_PARENTHESIZED(test_launcher_template)<IMPL_UTEST_USER_FIXTURE(test_suite_name)>;
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_HIDE_USER_FIXTURE_BY_TEST_LAUNCHER_TYPED(test_suite_name)
    template <typename UtestTypeParamImpl>
    using IMPL_UTEST_NON_PARENTHESIZED(test_suite_name) = USERVER_NAMESPACE::utest::impl::
        TestLauncherTyped<IMPL_UTEST_USER_FIXTURE(test_suite_name), UtestTypeParamImpl>;
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_TEST(test_suite_name, test_name, thread_count, death_tests_enabled)
    struct IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name) final {
        class EnrichedTest final : public USERVER_NAMESPACE::utest::impl::EnrichedFixture<::testing::Test> {
            void TestBody() override;
        };
    };
    TEST(test_suite_name, test_name) {
        using EnrichedTest = IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name)::EnrichedTest;
        USERVER_NAMESPACE::utest::impl::TestLauncher<::testing::Test>::RunTest<EnrichedTest>(
            thread_count, death_tests_enabled
        );
    }
    void IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name)::EnrichedTest::TestBody()
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_ANY_BEGIN(test_suite_name, test_name, test_launcher_template)
    IMPL_UTEST_MAKE_USER_FIXTURE_ALIAS(test_suite_name);
    struct IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name) final {
        class EnrichedTest final
            : public USERVER_NAMESPACE::utest::impl::EnrichedFixture<IMPL_UTEST_USER_FIXTURE(test_suite_name)> {
            void TestBody() override;
        };
    };
    /* The 'namespace' trick is used to make gtest use our 'test_launcher'                                       \
     * instead of 'test_suite_name' fixture */
    namespace IMPL_UTEST_NAMESPACE_NAME(test_suite_name) {
    IMPL_UTEST_HIDE_USER_FIXTURE_BY_TEST_LAUNCHER(test_suite_name, test_launcher_template)
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_ANY_END(test_suite_name, test_name, thread_count, death_tests_enabled)
    /* test header goes here */ {
        using EnrichedTest = IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name)::EnrichedTest;
        this->RunTest<EnrichedTest>(thread_count, death_tests_enabled);
    }
    } /* namespace */
    void IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name)::EnrichedTest::TestBody()
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_TEST_F(test_suite_name, test_name, thread_count, death_tests_enabled)
    IMPL_UTEST_ANY_BEGIN(test_suite_name, test_name, USERVER_NAMESPACE::utest::impl::TestLauncher)
    TEST_F(test_suite_name, test_name)
    IMPL_UTEST_ANY_END(test_suite_name, test_name, thread_count, death_tests_enabled)
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_TEST_P(test_suite_name, test_name, thread_count, death_tests_enabled)
    IMPL_UTEST_ANY_BEGIN(test_suite_name, test_name, USERVER_NAMESPACE::utest::impl::TestLauncherParametric)
    TEST_P(test_suite_name, test_name)
    IMPL_UTEST_ANY_END(test_suite_name, test_name, thread_count, death_tests_enabled)
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_TYPED_ANY_BEGIN(test_suite_name, test_name)
    IMPL_UTEST_MAKE_USER_FIXTURE_ALIAS_TYPED(test_suite_name);
    struct IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name) final {
        template <typename UtestTypeParamImpl>
        using UtestUserFixture = IMPL_UTEST_USER_FIXTURE(test_suite_name)<UtestTypeParamImpl>;
 
        template <typename UtestTypeParamImpl>
        class EnrichedTest
            : public USERVER_NAMESPACE::utest::impl::EnrichedFixture<UtestUserFixture<UtestTypeParamImpl>> {
            using TypeParam = UtestTypeParamImpl;
            using TestFixture = IMPL_UTEST_NON_PARENTHESIZED(test_suite_name)<TypeParam>;
            using USERVER_NAMESPACE::utest::impl::EnrichedTestBase::GetThreadCount;
            void TestBody() override;
        };
    };
    /* The 'namespace' trick is used to make gtest use our 'TestLauncher'                                    \
     * instead of 'test_suite_name' fixture */
    namespace IMPL_UTEST_NAMESPACE_NAME(test_suite_name) {
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_TYPED_ANY_END(test_suite_name, test_name, thread_count, death_tests_enabled)
    /* test header goes here */ {
        using EnrichedTest = IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name)::EnrichedTest<TypeParam>;
        this->template RunTest<EnrichedTest>(thread_count, death_tests_enabled);
    }
    } /* namespace */
    template <typename UtestTypeParamImpl>
    void IMPL_UTEST_HIDE_ENRICHED_FROM_IDE(test_suite_name, test_name)::EnrichedTest<UtestTypeParamImpl>::TestBody()
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_TYPED_TEST(test_suite_name, test_name, thread_count, death_tests_enabled)
    IMPL_UTEST_TYPED_ANY_BEGIN(test_suite_name, test_name)
    TYPED_TEST(test_suite_name, test_name)
    IMPL_UTEST_TYPED_ANY_END(test_suite_name, test_name, thread_count, death_tests_enabled)
 
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IMPL_UTEST_TYPED_TEST_P(test_suite_name, test_name, thread_count, death_tests_enabled)
    IMPL_UTEST_TYPED_ANY_BEGIN(test_suite_name, test_name)
    TYPED_TEST_P(test_suite_name, test_name)
    IMPL_UTEST_TYPED_ANY_END(test_suite_name, test_name, thread_count, death_tests_enabled)