Testing.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_TESTING
#define SC_EXPORT_LIBRARY_TESTING 0
#endif
#define SC_TESTING_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_TESTING)
 
#include "../Common/Assert.h"
#include "../Common/IGrowableBufferStringPath.h"
#include "../Common/Result.h"
#include "../Common/StringSpan.h"
 
namespace SC
{
SC_DECLARE_ASSERT_PROVIDER(TestingAssert, SC_TESTING_EXPORT);
 
#define SC_TESTING_ASSERT_RELEASE(e)        SC_ASSERT_PROVIDER_RELEASE(SC::TestingAssert, e)
#define SC_TESTING_ASSERT_DEBUG(e)          SC_ASSERT_PROVIDER_DEBUG(SC::TestingAssert, e)
#define SC_TESTING_TRUST_RESULT(expression) SC_TESTING_ASSERT_RELEASE(expression)
 
struct TestCase;
 
 
struct TestReport
{
    struct IOutput
    {
        virtual ~IOutput() = default;
 
        virtual void flush()                                              = 0;
        virtual void printLine(StringSpan text)                           = 0;
        virtual void print(StringSpan text)                               = 0;
        virtual void print(StringSpan text, StringSpan p0)                = 0;
        virtual void print(StringSpan text, StringSpan p0, StringSpan p1) = 0;
        virtual void print(StringSpan text, size_t p0)                    = 0;
        virtual void print(StringSpan text, size_t p0, size_t p1)         = 0;
    };
 
    template <typename ConsoleType>
    struct Output final : public TestReport::IOutput
    {
        ConsoleType& console;
        Output(ConsoleType& console) : console(console) {}
 
        virtual void flush() override { console.flush(); }
        virtual void printLine(StringSpan text) override { console.printLine(text); }
        virtual void print(StringSpan text) override { console.print(text); }
        virtual void print(StringSpan text, StringSpan p0) override { console.print(text, p0); }
        virtual void print(StringSpan text, StringSpan p0, StringSpan p1) override { console.print(text, p0, p1); }
        virtual void print(StringSpan text, size_t p0) override { console.print(text, p0); }
        virtual void print(StringSpan text, size_t p0, size_t p1) override { console.print(text, p0, p1); }
    };
    IOutput& console;
 
    StringPath libraryRootDirectory;     
    StringPath executableFile;           
    StringPath applicationRootDirectory; 
 
    // Options
    bool abortOnFirstFailedTest = true;  
    bool debugBreakOnFailedTest = true;  
    bool quietMode              = false; 
    bool runAllTests            = false; 
 
    TestReport(IOutput& console, int argc, const char** argv);
    ~TestReport();
 
    [[nodiscard]] int getTestReturnCode() const;
 
    [[nodiscard]] bool hasStartupFailure() const { return startupFailure; }
 
    [[nodiscard]] uint16_t mapPort(uint16_t basePort) const;
 
    [[nodiscard]] bool isTestExplicitlySelected(StringSpan testName) const;
 
    [[nodiscard]] bool isTestEnabled(StringSpan testName) const;
 
    template <typename Statistics>
    void runGlobalMemoryReport(Statistics stats, bool reportFailure = true)
    {
        TestReport::MemoryStatistics memStats;
        memStats.numAllocate   = stats.numAllocate;
        memStats.numReallocate = stats.numReallocate;
        memStats.numRelease    = stats.numRelease;
        internalRunGlobalMemoryReport(memStats, reportFailure);
    }
 
  private:
    struct MemoryStatistics
    {
        size_t numAllocate   = 0; 
        size_t numReallocate = 0; 
        size_t numRelease    = 0; 
    };
 
    void internalRunGlobalMemoryReport(MemoryStatistics stats, bool reportFailure);
 
    [[nodiscard]] bool isSectionEnabled(StringSpan sectionName) const;
 
    void testCaseFinished(TestCase& testCase);
    void printSectionResult(TestCase& testCase);
 
    friend struct TestCase;
    uint32_t   numTestsSucceeded = 0;
    uint32_t   numTestsFailed    = 0;
    uint16_t   portOffset        = 0;
    StringSpan currentSection;
    StringSpan firstFailedTest;
    StringSpan testToRun;
    StringSpan sectionToRun;
    bool       startupFailure = false;
};
 
struct TestCase
{
    TestCase(TestReport& report, StringSpan testName);
    ~TestCase();
 
    bool recordExpectation(StringSpan expression, bool status, StringSpan detailedError = StringSpan());
 
    bool recordExpectation(StringSpan expression, Result status);
 
#if SC_PLATFORM_WINDOWS
#define SC_TESTING_NO_INLINE __declspec(noinline)
#else
#define SC_TESTING_NO_INLINE __attribute__((noinline))
#endif
 
    template <typename Test>
    static SC_TESTING_NO_INLINE bool recordLiteralExpectation(Test& test, const char* expression, size_t length,
                                                              bool status)
    {
        return test.recordExpectation(StringSpan({expression, length}, true, StringEncoding::Ascii), status);
    }
 
    template <typename Test>
    static SC_TESTING_NO_INLINE bool recordLiteralExpectation(Test& test, const char* expression, size_t length,
                                                              Result status)
    {
        return test.recordExpectation(StringSpan({expression, length}, true, StringEncoding::Ascii), status);
    }
 
#undef SC_TESTING_NO_INLINE
 
    enum class Execute
    {
        Default,     
        OnlyExplicit 
    };
 
    [[nodiscard]] bool test_section(StringSpan sectionName, Execute execution = Execute::Default);
 
    TestReport& report; 
  private:
    friend struct TestReport;
    const StringSpan testName;
 
    uint32_t numTestsSucceeded;
    uint32_t numTestsFailed;
    uint32_t numSectionTestsFailed;
    bool     printedSection;
};
 
// clang-format off
#define SC_TEST_EXPECT(e) TestCase::recordLiteralExpectation(*this, #e, sizeof(#e) - 1, (e)) ? (void)0 : (TestCase::report.debugBreakOnFailedTest ? SC_COMPILER_DEBUG_BREAK : (void)0)
// clang-format on
 
} // namespace SC