1// ====================================================================== lgtm [cpp/missing-header-guard] 2// == DO NOT MODIFY THIS FILE BY HAND - IT IS AUTO GENERATED BY CMAKE! == 3// ====================================================================== 4// 5// doctest.h - the lightest feature-rich C++ single-header testing framework for unit tests and TDD 6// 7// Copyright (c) 2016-2021 Viktor Kirilov 8// 9// Distributed under the MIT Software License 10// See accompanying file LICENSE.txt or copy at 11// https://opensource.org/licenses/MIT 12// 13// The documentation can be found at the library's page: 14// https://github.com/onqtam/doctest/blob/master/doc/markdown/readme.md 15// 16// ================================================================================================= 17// ================================================================================================= 18// ================================================================================================= 19// 20// The library is heavily influenced by Catch - https://github.com/catchorg/Catch2 21// which uses the Boost Software License - Version 1.0 22// see here - https://github.com/catchorg/Catch2/blob/master/LICENSE.txt 23// 24// The concept of subcases (sections in Catch) and expression decomposition are from there. 25// Some parts of the code are taken directly: 26// - stringification - the detection of "ostream& operator<<(ostream&, const T&)" and StringMaker<> 27// - the Approx() helper class for floating point comparison 28// - colors in the console 29// - breaking into a debugger 30// - signal / SEH handling 31// - timer 32// - XmlWriter class - thanks to Phil Nash for allowing the direct reuse (AKA copy/paste) 33// 34// The expression decomposing templates are taken from lest - https://github.com/martinmoene/lest 35// which uses the Boost Software License - Version 1.0 36// see here - https://github.com/martinmoene/lest/blob/master/LICENSE.txt 37// 38// ================================================================================================= 39// ================================================================================================= 40// ================================================================================================= 41 42#ifndef DOCTEST_LIBRARY_INCLUDED 43#define DOCTEST_LIBRARY_INCLUDED 44 45// ================================================================================================= 46// == VERSION ====================================================================================== 47// ================================================================================================= 48 49#define DOCTEST_VERSION_MAJOR 2 50#define DOCTEST_VERSION_MINOR 4 51#define DOCTEST_VERSION_PATCH 6 52#define DOCTEST_VERSION_STR "2.4.6" 53 54#define DOCTEST_VERSION \ 55 (DOCTEST_VERSION_MAJOR * 10000 + DOCTEST_VERSION_MINOR * 100 + DOCTEST_VERSION_PATCH) 56 57// ================================================================================================= 58// == COMPILER VERSION ============================================================================= 59// ================================================================================================= 60 61// ideas for the version stuff are taken from here: https://github.com/cxxstuff/cxx_detect 62 63#define DOCTEST_COMPILER(MAJOR, MINOR, PATCH) ((MAJOR)*10000000 + (MINOR)*100000 + (PATCH)) 64 65// GCC/Clang and GCC/MSVC are mutually exclusive, but Clang/MSVC are not because of clang-cl... 66#if defined(_MSC_VER) && defined(_MSC_FULL_VER) 67#if _MSC_VER == _MSC_FULL_VER / 10000 68#define DOCTEST_MSVC DOCTEST_COMPILER(_MSC_VER / 100, _MSC_VER % 100, _MSC_FULL_VER % 10000) 69#else // MSVC 70#define DOCTEST_MSVC \ 71 DOCTEST_COMPILER(_MSC_VER / 100, (_MSC_FULL_VER / 100000) % 100, _MSC_FULL_VER % 100000) 72#endif // MSVC 73#endif // MSVC 74#if defined(__clang__) && defined(__clang_minor__) 75#define DOCTEST_CLANG DOCTEST_COMPILER(__clang_major__, __clang_minor__, __clang_patchlevel__) 76#elif defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) && \ 77 !defined(__INTEL_COMPILER) 78#define DOCTEST_GCC DOCTEST_COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) 79#endif // GCC 80 81#ifndef DOCTEST_MSVC 82#define DOCTEST_MSVC 0 83#endif // DOCTEST_MSVC 84#ifndef DOCTEST_CLANG 85#define DOCTEST_CLANG 0 86#endif // DOCTEST_CLANG 87#ifndef DOCTEST_GCC 88#define DOCTEST_GCC 0 89#endif // DOCTEST_GCC 90 91// ================================================================================================= 92// == COMPILER WARNINGS HELPERS ==================================================================== 93// ================================================================================================= 94 95#if DOCTEST_CLANG 96#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x) 97#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH _Pragma("clang diagnostic push") 98#define DOCTEST_CLANG_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(clang diagnostic ignored w) 99#define DOCTEST_CLANG_SUPPRESS_WARNING_POP _Pragma("clang diagnostic pop") 100#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w) \ 101 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH DOCTEST_CLANG_SUPPRESS_WARNING(w) 102#else // DOCTEST_CLANG 103#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH 104#define DOCTEST_CLANG_SUPPRESS_WARNING(w) 105#define DOCTEST_CLANG_SUPPRESS_WARNING_POP 106#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w) 107#endif // DOCTEST_CLANG 108 109#if DOCTEST_GCC 110#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x) 111#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH _Pragma("GCC diagnostic push") 112#define DOCTEST_GCC_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(GCC diagnostic ignored w) 113#define DOCTEST_GCC_SUPPRESS_WARNING_POP _Pragma("GCC diagnostic pop") 114#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w) \ 115 DOCTEST_GCC_SUPPRESS_WARNING_PUSH DOCTEST_GCC_SUPPRESS_WARNING(w) 116#else // DOCTEST_GCC 117#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH 118#define DOCTEST_GCC_SUPPRESS_WARNING(w) 119#define DOCTEST_GCC_SUPPRESS_WARNING_POP 120#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w) 121#endif // DOCTEST_GCC 122 123#if DOCTEST_MSVC 124#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH __pragma(warning(push)) 125#define DOCTEST_MSVC_SUPPRESS_WARNING(w) __pragma(warning(disable : w)) 126#define DOCTEST_MSVC_SUPPRESS_WARNING_POP __pragma(warning(pop)) 127#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w) \ 128 DOCTEST_MSVC_SUPPRESS_WARNING_PUSH DOCTEST_MSVC_SUPPRESS_WARNING(w) 129#else // DOCTEST_MSVC 130#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH 131#define DOCTEST_MSVC_SUPPRESS_WARNING(w) 132#define DOCTEST_MSVC_SUPPRESS_WARNING_POP 133#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w) 134#endif // DOCTEST_MSVC 135 136// ================================================================================================= 137// == COMPILER WARNINGS ============================================================================ 138// ================================================================================================= 139 140DOCTEST_CLANG_SUPPRESS_WARNING_PUSH 141DOCTEST_CLANG_SUPPRESS_WARNING("-Wunknown-pragmas") 142DOCTEST_CLANG_SUPPRESS_WARNING("-Wnon-virtual-dtor") 143DOCTEST_CLANG_SUPPRESS_WARNING("-Wweak-vtables") 144DOCTEST_CLANG_SUPPRESS_WARNING("-Wpadded") 145DOCTEST_CLANG_SUPPRESS_WARNING("-Wdeprecated") 146DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes") 147DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-local-typedef") 148DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat") 149DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic") 150 151DOCTEST_GCC_SUPPRESS_WARNING_PUSH 152DOCTEST_GCC_SUPPRESS_WARNING("-Wunknown-pragmas") 153DOCTEST_GCC_SUPPRESS_WARNING("-Wpragmas") 154DOCTEST_GCC_SUPPRESS_WARNING("-Weffc++") 155DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-overflow") 156DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-aliasing") 157DOCTEST_GCC_SUPPRESS_WARNING("-Wctor-dtor-privacy") 158DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-declarations") 159DOCTEST_GCC_SUPPRESS_WARNING("-Wnon-virtual-dtor") 160DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-local-typedefs") 161DOCTEST_GCC_SUPPRESS_WARNING("-Wuseless-cast") 162DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept") 163DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-promo") 164 165DOCTEST_MSVC_SUPPRESS_WARNING_PUSH 166DOCTEST_MSVC_SUPPRESS_WARNING(4616) // invalid compiler warning 167DOCTEST_MSVC_SUPPRESS_WARNING(4619) // invalid compiler warning 168DOCTEST_MSVC_SUPPRESS_WARNING(4996) // The compiler encountered a deprecated declaration 169DOCTEST_MSVC_SUPPRESS_WARNING(4706) // assignment within conditional expression 170DOCTEST_MSVC_SUPPRESS_WARNING(4512) // 'class' : assignment operator could not be generated 171DOCTEST_MSVC_SUPPRESS_WARNING(4127) // conditional expression is constant 172DOCTEST_MSVC_SUPPRESS_WARNING(4820) // padding 173DOCTEST_MSVC_SUPPRESS_WARNING(4625) // copy constructor was implicitly defined as deleted 174DOCTEST_MSVC_SUPPRESS_WARNING(4626) // assignment operator was implicitly defined as deleted 175DOCTEST_MSVC_SUPPRESS_WARNING(5027) // move assignment operator was implicitly defined as deleted 176DOCTEST_MSVC_SUPPRESS_WARNING(5026) // move constructor was implicitly defined as deleted 177DOCTEST_MSVC_SUPPRESS_WARNING(4623) // default constructor was implicitly defined as deleted 178DOCTEST_MSVC_SUPPRESS_WARNING(4640) // construction of local static object is not thread-safe 179// static analysis 180DOCTEST_MSVC_SUPPRESS_WARNING(26439) // This kind of function may not throw. Declare it 'noexcept' 181DOCTEST_MSVC_SUPPRESS_WARNING(26495) // Always initialize a member variable 182DOCTEST_MSVC_SUPPRESS_WARNING(26451) // Arithmetic overflow ... 183DOCTEST_MSVC_SUPPRESS_WARNING(26444) // Avoid unnamed objects with custom construction and dtr... 184DOCTEST_MSVC_SUPPRESS_WARNING(26812) // Prefer 'enum class' over 'enum' 185 186// 4548 - expression before comma has no effect; expected expression with side - effect 187// 4265 - class has virtual functions, but destructor is not virtual 188// 4986 - exception specification does not match previous declaration 189// 4350 - behavior change: 'member1' called instead of 'member2' 190// 4668 - 'x' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif' 191// 4365 - conversion from 'int' to 'unsigned long', signed/unsigned mismatch 192// 4774 - format string expected in argument 'x' is not a string literal 193// 4820 - padding in structs 194 195// only 4 should be disabled globally: 196// - 4514 # unreferenced inline function has been removed 197// - 4571 # SEH related 198// - 4710 # function not inlined 199// - 4711 # function 'x' selected for automatic inline expansion 200 201#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN \ 202 DOCTEST_MSVC_SUPPRESS_WARNING_PUSH \ 203 DOCTEST_MSVC_SUPPRESS_WARNING(4548) \ 204 DOCTEST_MSVC_SUPPRESS_WARNING(4265) \ 205 DOCTEST_MSVC_SUPPRESS_WARNING(4986) \ 206 DOCTEST_MSVC_SUPPRESS_WARNING(4350) \ 207 DOCTEST_MSVC_SUPPRESS_WARNING(4668) \ 208 DOCTEST_MSVC_SUPPRESS_WARNING(4365) \ 209 DOCTEST_MSVC_SUPPRESS_WARNING(4774) \ 210 DOCTEST_MSVC_SUPPRESS_WARNING(4820) \ 211 DOCTEST_MSVC_SUPPRESS_WARNING(4625) \ 212 DOCTEST_MSVC_SUPPRESS_WARNING(4626) \ 213 DOCTEST_MSVC_SUPPRESS_WARNING(5027) \ 214 DOCTEST_MSVC_SUPPRESS_WARNING(5026) \ 215 DOCTEST_MSVC_SUPPRESS_WARNING(4623) \ 216 DOCTEST_MSVC_SUPPRESS_WARNING(5039) \ 217 DOCTEST_MSVC_SUPPRESS_WARNING(5045) \ 218 DOCTEST_MSVC_SUPPRESS_WARNING(5105) 219 220#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END DOCTEST_MSVC_SUPPRESS_WARNING_POP 221 222// ================================================================================================= 223// == FEATURE DETECTION ============================================================================ 224// ================================================================================================= 225 226// general compiler feature support table: https://en.cppreference.com/w/cpp/compiler_support 227// MSVC C++11 feature support table: https://msdn.microsoft.com/en-us/library/hh567368.aspx 228// GCC C++11 feature support table: https://gcc.gnu.org/projects/cxx-status.html 229// MSVC version table: 230// https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering 231// MSVC++ 14.2 (16) _MSC_VER == 1920 (Visual Studio 2019) 232// MSVC++ 14.1 (15) _MSC_VER == 1910 (Visual Studio 2017) 233// MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015) 234// MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013) 235// MSVC++ 11.0 _MSC_VER == 1700 (Visual Studio 2012) 236// MSVC++ 10.0 _MSC_VER == 1600 (Visual Studio 2010) 237// MSVC++ 9.0 _MSC_VER == 1500 (Visual Studio 2008) 238// MSVC++ 8.0 _MSC_VER == 1400 (Visual Studio 2005) 239 240#if DOCTEST_MSVC && !defined(DOCTEST_CONFIG_WINDOWS_SEH) 241#define DOCTEST_CONFIG_WINDOWS_SEH 242#endif // MSVC 243#if defined(DOCTEST_CONFIG_NO_WINDOWS_SEH) && defined(DOCTEST_CONFIG_WINDOWS_SEH) 244#undef DOCTEST_CONFIG_WINDOWS_SEH 245#endif // DOCTEST_CONFIG_NO_WINDOWS_SEH 246 247#if !defined(_WIN32) && !defined(__QNX__) && !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && \ 248 !defined(__EMSCRIPTEN__) 249#define DOCTEST_CONFIG_POSIX_SIGNALS 250#endif // _WIN32 251#if defined(DOCTEST_CONFIG_NO_POSIX_SIGNALS) && defined(DOCTEST_CONFIG_POSIX_SIGNALS) 252#undef DOCTEST_CONFIG_POSIX_SIGNALS 253#endif // DOCTEST_CONFIG_NO_POSIX_SIGNALS 254 255#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 256#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND) 257#define DOCTEST_CONFIG_NO_EXCEPTIONS 258#endif // no exceptions 259#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 260 261#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS 262#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 263#define DOCTEST_CONFIG_NO_EXCEPTIONS 264#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 265#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS 266 267#if defined(DOCTEST_CONFIG_NO_EXCEPTIONS) && !defined(DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS) 268#define DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS 269#endif // DOCTEST_CONFIG_NO_EXCEPTIONS && !DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS 270 271#if defined(DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN) && !defined(DOCTEST_CONFIG_IMPLEMENT) 272#define DOCTEST_CONFIG_IMPLEMENT 273#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 274 275#if defined(_WIN32) || defined(__CYGWIN__) 276#if DOCTEST_MSVC 277#define DOCTEST_SYMBOL_EXPORT __declspec(dllexport) 278#define DOCTEST_SYMBOL_IMPORT __declspec(dllimport) 279#else // MSVC 280#define DOCTEST_SYMBOL_EXPORT __attribute__((dllexport)) 281#define DOCTEST_SYMBOL_IMPORT __attribute__((dllimport)) 282#endif // MSVC 283#else // _WIN32 284#define DOCTEST_SYMBOL_EXPORT __attribute__((visibility("default"))) 285#define DOCTEST_SYMBOL_IMPORT 286#endif // _WIN32 287 288#ifdef DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL 289#ifdef DOCTEST_CONFIG_IMPLEMENT 290#define DOCTEST_INTERFACE DOCTEST_SYMBOL_EXPORT 291#else // DOCTEST_CONFIG_IMPLEMENT 292#define DOCTEST_INTERFACE DOCTEST_SYMBOL_IMPORT 293#endif // DOCTEST_CONFIG_IMPLEMENT 294#else // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL 295#define DOCTEST_INTERFACE 296#endif // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL 297 298#define DOCTEST_EMPTY 299 300#if DOCTEST_MSVC 301#define DOCTEST_NOINLINE __declspec(noinline) 302#define DOCTEST_UNUSED 303#define DOCTEST_ALIGNMENT(x) 304#elif DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 5, 0) 305#define DOCTEST_NOINLINE 306#define DOCTEST_UNUSED 307#define DOCTEST_ALIGNMENT(x) 308#else 309#define DOCTEST_NOINLINE __attribute__((noinline)) 310#define DOCTEST_UNUSED __attribute__((unused)) 311#define DOCTEST_ALIGNMENT(x) __attribute__((aligned(x))) 312#endif 313 314#ifndef DOCTEST_NORETURN 315#define DOCTEST_NORETURN [[noreturn]] 316#endif // DOCTEST_NORETURN 317 318#ifndef DOCTEST_NOEXCEPT 319#define DOCTEST_NOEXCEPT noexcept 320#endif // DOCTEST_NOEXCEPT 321 322// ================================================================================================= 323// == FEATURE DETECTION END ======================================================================== 324// ================================================================================================= 325 326// internal macros for string concatenation and anonymous variable name generation 327#define DOCTEST_CAT_IMPL(s1, s2) s1##s2 328#define DOCTEST_CAT(s1, s2) DOCTEST_CAT_IMPL(s1, s2) 329#ifdef __COUNTER__ // not standard and may be missing for some compilers 330#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __COUNTER__) 331#else // __COUNTER__ 332#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __LINE__) 333#endif // __COUNTER__ 334 335#define DOCTEST_TOSTR(x) #x 336 337#ifndef DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE 338#define DOCTEST_REF_WRAP(x) x& 339#else // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE 340#define DOCTEST_REF_WRAP(x) x 341#endif // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE 342 343// not using __APPLE__ because... this is how Catch does it 344#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED 345#define DOCTEST_PLATFORM_MAC 346#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) 347#define DOCTEST_PLATFORM_IPHONE 348#elif defined(_WIN32) 349#define DOCTEST_PLATFORM_WINDOWS 350#else // DOCTEST_PLATFORM 351#define DOCTEST_PLATFORM_LINUX 352#endif // DOCTEST_PLATFORM 353 354#define DOCTEST_GLOBAL_NO_WARNINGS(var) \ 355 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wglobal-constructors") \ 356 DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-variable") \ 357 static const int var DOCTEST_UNUSED // NOLINT(fuchsia-statically-constructed-objects,cert-err58-cpp) 358#define DOCTEST_GLOBAL_NO_WARNINGS_END() DOCTEST_CLANG_SUPPRESS_WARNING_POP 359 360#ifndef DOCTEST_BREAK_INTO_DEBUGGER 361// should probably take a look at https://github.com/scottt/debugbreak 362#ifdef DOCTEST_PLATFORM_LINUX 363#if defined(__GNUC__) && (defined(__i386) || defined(__x86_64)) 364// Break at the location of the failing check if possible 365#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT (hicpp-no-assembler) 366#else 367#include <signal.h> 368#define DOCTEST_BREAK_INTO_DEBUGGER() raise(SIGTRAP) 369#endif 370#elif defined(DOCTEST_PLATFORM_MAC) 371#if defined(__x86_64) || defined(__x86_64__) || defined(__amd64__) || defined(__i386) 372#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT (hicpp-no-assembler) 373#else 374#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("brk #0"); // NOLINT (hicpp-no-assembler) 375#endif 376#elif DOCTEST_MSVC 377#define DOCTEST_BREAK_INTO_DEBUGGER() __debugbreak() 378#elif defined(__MINGW32__) 379DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wredundant-decls") 380extern "C" __declspec(dllimport) void __stdcall DebugBreak(); 381DOCTEST_GCC_SUPPRESS_WARNING_POP 382#define DOCTEST_BREAK_INTO_DEBUGGER() ::DebugBreak() 383#else // linux 384#define DOCTEST_BREAK_INTO_DEBUGGER() (static_cast<void>(0)) 385#endif // linux 386#endif // DOCTEST_BREAK_INTO_DEBUGGER 387 388// this is kept here for backwards compatibility since the config option was changed 389#ifdef DOCTEST_CONFIG_USE_IOSFWD 390#define DOCTEST_CONFIG_USE_STD_HEADERS 391#endif // DOCTEST_CONFIG_USE_IOSFWD 392 393#ifdef DOCTEST_CONFIG_USE_STD_HEADERS 394#ifndef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 395#define DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 396#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 397#include <iosfwd> 398#include <cstddef> 399#include <ostream> 400#else // DOCTEST_CONFIG_USE_STD_HEADERS 401 402#if DOCTEST_CLANG 403// to detect if libc++ is being used with clang (the _LIBCPP_VERSION identifier) 404#include <ciso646> 405#endif // clang 406 407#ifdef _LIBCPP_VERSION 408#define DOCTEST_STD_NAMESPACE_BEGIN _LIBCPP_BEGIN_NAMESPACE_STD 409#define DOCTEST_STD_NAMESPACE_END _LIBCPP_END_NAMESPACE_STD 410#else // _LIBCPP_VERSION 411#define DOCTEST_STD_NAMESPACE_BEGIN namespace std { 412#define DOCTEST_STD_NAMESPACE_END } 413#endif // _LIBCPP_VERSION 414 415// Forward declaring 'X' in namespace std is not permitted by the C++ Standard. 416DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4643) 417 418DOCTEST_STD_NAMESPACE_BEGIN // NOLINT (cert-dcl58-cpp) 419typedef decltype(nullptr) nullptr_t; 420template <class charT> 421struct char_traits; 422template <> 423struct char_traits<char>; 424template <class charT, class traits> 425class basic_ostream; 426typedef basic_ostream<char, char_traits<char>> ostream; 427template <class... Types> 428class tuple; 429#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0) 430// see this issue on why this is needed: https://github.com/onqtam/doctest/issues/183 431template <class _Ty> 432class allocator; 433template <class _Elem, class _Traits, class _Alloc> 434class basic_string; 435using string = basic_string<char, char_traits<char>, allocator<char>>; 436#endif // VS 2019 437DOCTEST_STD_NAMESPACE_END 438 439DOCTEST_MSVC_SUPPRESS_WARNING_POP 440 441#endif // DOCTEST_CONFIG_USE_STD_HEADERS 442 443#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 444#include <type_traits> 445#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 446 447namespace doctest { 448 449DOCTEST_INTERFACE extern bool is_running_in_test; 450 451// A 24 byte string class (can be as small as 17 for x64 and 13 for x86) that can hold strings with length 452// of up to 23 chars on the stack before going on the heap - the last byte of the buffer is used for: 453// - "is small" bit - the highest bit - if "0" then it is small - otherwise its "1" (128) 454// - if small - capacity left before going on the heap - using the lowest 5 bits 455// - if small - 2 bits are left unused - the second and third highest ones 456// - if small - acts as a null terminator if strlen() is 23 (24 including the null terminator) 457// and the "is small" bit remains "0" ("as well as the capacity left") so its OK 458// Idea taken from this lecture about the string implementation of facebook/folly - fbstring 459// https://www.youtube.com/watch?v=kPR8h4-qZdk 460// TODO: 461// - optimizations - like not deleting memory unnecessarily in operator= and etc. 462// - resize/reserve/clear 463// - substr 464// - replace 465// - back/front 466// - iterator stuff 467// - find & friends 468// - push_back/pop_back 469// - assign/insert/erase 470// - relational operators as free functions - taking const char* as one of the params 471class DOCTEST_INTERFACE String 472{ 473 static const unsigned len = 24; //!OCLINT avoid private static members 474 static const unsigned last = len - 1; //!OCLINT avoid private static members 475 476 struct view // len should be more than sizeof(view) - because of the final byte for flags 477 { 478 char* ptr; 479 unsigned size; 480 unsigned capacity; 481 }; 482 483 union 484 { 485 char buf[len]; 486 view data; 487 }; 488 489 bool isOnStack() const { return (buf[last] & 128) == 0; } 490 void setOnHeap(); 491 void setLast(unsigned in = last); 492 493 void copy(const String& other); 494 495public: 496 String(); 497 ~String(); 498 499 // cppcheck-suppress noExplicitConstructor 500 String(const char* in); 501 String(const char* in, unsigned in_size); 502 503 String(const String& other); 504 String& operator=(const String& other); 505 506 String& operator+=(const String& other); 507 String operator+(const String& other) const; 508 509 String(String&& other); 510 String& operator=(String&& other); 511 512 char operator[](unsigned i) const; 513 char& operator[](unsigned i); 514 515 // the only functions I'm willing to leave in the interface - available for inlining 516 const char* c_str() const { return const_cast<String*>(this)->c_str(); } // NOLINT 517 char* c_str() { 518 if(isOnStack()) 519 return reinterpret_cast<char*>(buf); 520 return data.ptr; 521 } 522 523 unsigned size() const; 524 unsigned capacity() const; 525 526 int compare(const char* other, bool no_case = false) const; 527 int compare(const String& other, bool no_case = false) const; 528}; 529 530DOCTEST_INTERFACE bool operator==(const String& lhs, const String& rhs); 531DOCTEST_INTERFACE bool operator!=(const String& lhs, const String& rhs); 532DOCTEST_INTERFACE bool operator<(const String& lhs, const String& rhs); 533DOCTEST_INTERFACE bool operator>(const String& lhs, const String& rhs); 534DOCTEST_INTERFACE bool operator<=(const String& lhs, const String& rhs); 535DOCTEST_INTERFACE bool operator>=(const String& lhs, const String& rhs); 536 537DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, const String& in); 538 539namespace Color { 540 enum Enum 541 { 542 None = 0, 543 White, 544 Red, 545 Green, 546 Blue, 547 Cyan, 548 Yellow, 549 Grey, 550 551 Bright = 0x10, 552 553 BrightRed = Bright | Red, 554 BrightGreen = Bright | Green, 555 LightGrey = Bright | Grey, 556 BrightWhite = Bright | White 557 }; 558 559 DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, Color::Enum code); 560} // namespace Color 561 562namespace assertType { 563 enum Enum 564 { 565 // macro traits 566 567 is_warn = 1, 568 is_check = 2 * is_warn, 569 is_require = 2 * is_check, 570 571 is_normal = 2 * is_require, 572 is_throws = 2 * is_normal, 573 is_throws_as = 2 * is_throws, 574 is_throws_with = 2 * is_throws_as, 575 is_nothrow = 2 * is_throws_with, 576 577 is_false = 2 * is_nothrow, 578 is_unary = 2 * is_false, // not checked anywhere - used just to distinguish the types 579 580 is_eq = 2 * is_unary, 581 is_ne = 2 * is_eq, 582 583 is_lt = 2 * is_ne, 584 is_gt = 2 * is_lt, 585 586 is_ge = 2 * is_gt, 587 is_le = 2 * is_ge, 588 589 // macro types 590 591 DT_WARN = is_normal | is_warn, 592 DT_CHECK = is_normal | is_check, 593 DT_REQUIRE = is_normal | is_require, 594 595 DT_WARN_FALSE = is_normal | is_false | is_warn, 596 DT_CHECK_FALSE = is_normal | is_false | is_check, 597 DT_REQUIRE_FALSE = is_normal | is_false | is_require, 598 599 DT_WARN_THROWS = is_throws | is_warn, 600 DT_CHECK_THROWS = is_throws | is_check, 601 DT_REQUIRE_THROWS = is_throws | is_require, 602 603 DT_WARN_THROWS_AS = is_throws_as | is_warn, 604 DT_CHECK_THROWS_AS = is_throws_as | is_check, 605 DT_REQUIRE_THROWS_AS = is_throws_as | is_require, 606 607 DT_WARN_THROWS_WITH = is_throws_with | is_warn, 608 DT_CHECK_THROWS_WITH = is_throws_with | is_check, 609 DT_REQUIRE_THROWS_WITH = is_throws_with | is_require, 610 611 DT_WARN_THROWS_WITH_AS = is_throws_with | is_throws_as | is_warn, 612 DT_CHECK_THROWS_WITH_AS = is_throws_with | is_throws_as | is_check, 613 DT_REQUIRE_THROWS_WITH_AS = is_throws_with | is_throws_as | is_require, 614 615 DT_WARN_NOTHROW = is_nothrow | is_warn, 616 DT_CHECK_NOTHROW = is_nothrow | is_check, 617 DT_REQUIRE_NOTHROW = is_nothrow | is_require, 618 619 DT_WARN_EQ = is_normal | is_eq | is_warn, 620 DT_CHECK_EQ = is_normal | is_eq | is_check, 621 DT_REQUIRE_EQ = is_normal | is_eq | is_require, 622 623 DT_WARN_NE = is_normal | is_ne | is_warn, 624 DT_CHECK_NE = is_normal | is_ne | is_check, 625 DT_REQUIRE_NE = is_normal | is_ne | is_require, 626 627 DT_WARN_GT = is_normal | is_gt | is_warn, 628 DT_CHECK_GT = is_normal | is_gt | is_check, 629 DT_REQUIRE_GT = is_normal | is_gt | is_require, 630 631 DT_WARN_LT = is_normal | is_lt | is_warn, 632 DT_CHECK_LT = is_normal | is_lt | is_check, 633 DT_REQUIRE_LT = is_normal | is_lt | is_require, 634 635 DT_WARN_GE = is_normal | is_ge | is_warn, 636 DT_CHECK_GE = is_normal | is_ge | is_check, 637 DT_REQUIRE_GE = is_normal | is_ge | is_require, 638 639 DT_WARN_LE = is_normal | is_le | is_warn, 640 DT_CHECK_LE = is_normal | is_le | is_check, 641 DT_REQUIRE_LE = is_normal | is_le | is_require, 642 643 DT_WARN_UNARY = is_normal | is_unary | is_warn, 644 DT_CHECK_UNARY = is_normal | is_unary | is_check, 645 DT_REQUIRE_UNARY = is_normal | is_unary | is_require, 646 647 DT_WARN_UNARY_FALSE = is_normal | is_false | is_unary | is_warn, 648 DT_CHECK_UNARY_FALSE = is_normal | is_false | is_unary | is_check, 649 DT_REQUIRE_UNARY_FALSE = is_normal | is_false | is_unary | is_require, 650 }; 651} // namespace assertType 652 653DOCTEST_INTERFACE const char* assertString(assertType::Enum at); 654DOCTEST_INTERFACE const char* failureString(assertType::Enum at); 655DOCTEST_INTERFACE const char* skipPathFromFilename(const char* file); 656 657struct DOCTEST_INTERFACE TestCaseData 658{ 659 String m_file; // the file in which the test was registered (using String - see #350) 660 unsigned m_line; // the line where the test was registered 661 const char* m_name; // name of the test case 662 const char* m_test_suite; // the test suite in which the test was added 663 const char* m_description; 664 bool m_skip; 665 bool m_no_breaks; 666 bool m_no_output; 667 bool m_may_fail; 668 bool m_should_fail; 669 int m_expected_failures; 670 double m_timeout; 671}; 672 673struct DOCTEST_INTERFACE AssertData 674{ 675 // common - for all asserts 676 const TestCaseData* m_test_case; 677 assertType::Enum m_at; 678 const char* m_file; 679 int m_line; 680 const char* m_expr; 681 bool m_failed; 682 683 // exception-related - for all asserts 684 bool m_threw; 685 String m_exception; 686 687 // for normal asserts 688 String m_decomp; 689 690 // for specific exception-related asserts 691 bool m_threw_as; 692 const char* m_exception_type; 693 const char* m_exception_string; 694}; 695 696struct DOCTEST_INTERFACE MessageData 697{ 698 String m_string; 699 const char* m_file; 700 int m_line; 701 assertType::Enum m_severity; 702}; 703 704struct DOCTEST_INTERFACE SubcaseSignature 705{ 706 String m_name; 707 const char* m_file; 708 int m_line; 709 710 bool operator<(const SubcaseSignature& other) const; 711}; 712 713struct DOCTEST_INTERFACE IContextScope 714{ 715 IContextScope(); 716 virtual ~IContextScope(); 717 virtual void stringify(std::ostream*) const = 0; 718}; 719 720namespace detail { 721 struct DOCTEST_INTERFACE TestCase; 722} // namespace detail 723 724struct ContextOptions //!OCLINT too many fields 725{ 726 std::ostream* cout; // stdout stream - std::cout by default 727 std::ostream* cerr; // stderr stream - std::cerr by default 728 String binary_name; // the test binary name 729 730 const detail::TestCase* currentTest = nullptr; 731 732 // == parameters from the command line 733 String out; // output filename 734 String order_by; // how tests should be ordered 735 unsigned rand_seed; // the seed for rand ordering 736 737 unsigned first; // the first (matching) test to be executed 738 unsigned last; // the last (matching) test to be executed 739 740 int abort_after; // stop tests after this many failed assertions 741 int subcase_filter_levels; // apply the subcase filters for the first N levels 742 743 bool success; // include successful assertions in output 744 bool case_sensitive; // if filtering should be case sensitive 745 bool exit; // if the program should be exited after the tests are ran/whatever 746 bool duration; // print the time duration of each test case 747 bool no_throw; // to skip exceptions-related assertion macros 748 bool no_exitcode; // if the framework should return 0 as the exitcode 749 bool no_run; // to not run the tests at all (can be done with an "*" exclude) 750 bool no_version; // to not print the version of the framework 751 bool no_colors; // if output to the console should be colorized 752 bool force_colors; // forces the use of colors even when a tty cannot be detected 753 bool no_breaks; // to not break into the debugger 754 bool no_skip; // don't skip test cases which are marked to be skipped 755 bool gnu_file_line; // if line numbers should be surrounded with :x: and not (x): 756 bool no_path_in_filenames; // if the path to files should be removed from the output 757 bool no_line_numbers; // if source code line numbers should be omitted from the output 758 bool no_debug_output; // no output in the debug console when a debugger is attached 759 bool no_skipped_summary; // don't print "skipped" in the summary !!! UNDOCUMENTED !!! 760 bool no_time_in_output; // omit any time/timestamps from output !!! UNDOCUMENTED !!! 761 762 bool help; // to print the help 763 bool version; // to print the version 764 bool count; // if only the count of matching tests is to be retrieved 765 bool list_test_cases; // to list all tests matching the filters 766 bool list_test_suites; // to list all suites matching the filters 767 bool list_reporters; // lists all registered reporters 768}; 769 770namespace detail { 771 template <bool CONDITION, typename TYPE = void> 772 struct enable_if 773 {}; 774 775 template <typename TYPE> 776 struct enable_if<true, TYPE> 777 { typedef TYPE type; }; 778 779 // clang-format off 780 template<class T> struct remove_reference { typedef T type; }; 781 template<class T> struct remove_reference<T&> { typedef T type; }; 782 template<class T> struct remove_reference<T&&> { typedef T type; }; 783 784 template<typename T, typename U = T&&> U declval(int); 785 786 template<typename T> T declval(long); 787 788 template<typename T> auto declval() DOCTEST_NOEXCEPT -> decltype(declval<T>(0)) ; 789 790 template<class T> struct is_lvalue_reference { const static bool value=false; }; 791 template<class T> struct is_lvalue_reference<T&> { const static bool value=true; }; 792 793 template <class T> 794 inline T&& forward(typename remove_reference<T>::type& t) DOCTEST_NOEXCEPT 795 { 796 return static_cast<T&&>(t); 797 } 798 799 template <class T> 800 inline T&& forward(typename remove_reference<T>::type&& t) DOCTEST_NOEXCEPT 801 { 802 static_assert(!is_lvalue_reference<T>::value, 803 "Can not forward an rvalue as an lvalue."); 804 return static_cast<T&&>(t); 805 } 806 807 template<class T> struct remove_const { typedef T type; }; 808 template<class T> struct remove_const<const T> { typedef T type; }; 809#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 810 template<class T> struct is_enum : public std::is_enum<T> {}; 811 template<class T> struct underlying_type : public std::underlying_type<T> {}; 812#else 813 // Use compiler intrinsics 814 template<class T> struct is_enum { constexpr static bool value = __is_enum(T); }; 815 template<class T> struct underlying_type { typedef __underlying_type(T) type; }; 816#endif 817 // clang-format on 818 819 template <typename T> 820 struct deferred_false 821 // cppcheck-suppress unusedStructMember 822 { static const bool value = false; }; 823 824 namespace has_insertion_operator_impl { 825 std::ostream &os(); 826 template<class T> 827 DOCTEST_REF_WRAP(T) val(); 828 829 template<class, class = void> 830 struct check { 831 static constexpr bool value = false; 832 }; 833 834 template<class T> 835 struct check<T, decltype(os() << val<T>(), void())> { 836 static constexpr bool value = true; 837 }; 838 } // namespace has_insertion_operator_impl 839 840 template<class T> 841 using has_insertion_operator = has_insertion_operator_impl::check<const T>; 842 843 DOCTEST_INTERFACE void my_memcpy(void* dest, const void* src, unsigned num); 844 845 DOCTEST_INTERFACE std::ostream* getTlsOss(); // returns a thread-local ostringstream 846 DOCTEST_INTERFACE String getTlsOssResult(); 847 848 template <bool C> 849 struct StringMakerBase 850 { 851 template <typename T> 852 static String convert(const DOCTEST_REF_WRAP(T)) { 853 return "{?}"; 854 } 855 }; 856 857 template <> 858 struct StringMakerBase<true> 859 { 860 template <typename T> 861 static String convert(const DOCTEST_REF_WRAP(T) in) { 862 *getTlsOss() << in; 863 return getTlsOssResult(); 864 } 865 }; 866 867 DOCTEST_INTERFACE String rawMemoryToString(const void* object, unsigned size); 868 869 template <typename T> 870 String rawMemoryToString(const DOCTEST_REF_WRAP(T) object) { 871 return rawMemoryToString(&object, sizeof(object)); 872 } 873 874 template <typename T> 875 const char* type_to_string() { 876 return "<>"; 877 } 878} // namespace detail 879 880template <typename T> 881struct StringMaker : public detail::StringMakerBase<detail::has_insertion_operator<T>::value> 882{}; 883 884template <typename T> 885struct StringMaker<T*> 886{ 887 template <typename U> 888 static String convert(U* p) { 889 if(p) 890 return detail::rawMemoryToString(p); 891 return "NULL"; 892 } 893}; 894 895template <typename R, typename C> 896struct StringMaker<R C::*> 897{ 898 static String convert(R C::*p) { 899 if(p) 900 return detail::rawMemoryToString(p); 901 return "NULL"; 902 } 903}; 904 905template <typename T, typename detail::enable_if<!detail::is_enum<T>::value, bool>::type = true> 906String toString(const DOCTEST_REF_WRAP(T) value) { 907 return StringMaker<T>::convert(value); 908} 909 910#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 911DOCTEST_INTERFACE String toString(char* in); 912DOCTEST_INTERFACE String toString(const char* in); 913#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 914DOCTEST_INTERFACE String toString(bool in); 915DOCTEST_INTERFACE String toString(float in); 916DOCTEST_INTERFACE String toString(double in); 917DOCTEST_INTERFACE String toString(double long in); 918 919DOCTEST_INTERFACE String toString(char in); 920DOCTEST_INTERFACE String toString(char signed in); 921DOCTEST_INTERFACE String toString(char unsigned in); 922DOCTEST_INTERFACE String toString(int short in); 923DOCTEST_INTERFACE String toString(int short unsigned in); 924DOCTEST_INTERFACE String toString(int in); 925DOCTEST_INTERFACE String toString(int unsigned in); 926DOCTEST_INTERFACE String toString(int long in); 927DOCTEST_INTERFACE String toString(int long unsigned in); 928DOCTEST_INTERFACE String toString(int long long in); 929DOCTEST_INTERFACE String toString(int long long unsigned in); 930DOCTEST_INTERFACE String toString(std::nullptr_t in); 931 932template <typename T, typename detail::enable_if<detail::is_enum<T>::value, bool>::type = true> 933String toString(const DOCTEST_REF_WRAP(T) value) { 934 typedef typename detail::underlying_type<T>::type UT; 935 return toString(static_cast<UT>(value)); 936} 937 938#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0) 939// see this issue on why this is needed: https://github.com/onqtam/doctest/issues/183 940DOCTEST_INTERFACE String toString(const std::string& in); 941#endif // VS 2019 942 943class DOCTEST_INTERFACE Approx 944{ 945public: 946 explicit Approx(double value); 947 948 Approx operator()(double value) const; 949 950#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 951 template <typename T> 952 explicit Approx(const T& value, 953 typename detail::enable_if<std::is_constructible<double, T>::value>::type* = 954 static_cast<T*>(nullptr)) { 955 *this = Approx(static_cast<double>(value)); 956 } 957#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 958 959 Approx& epsilon(double newEpsilon); 960 961#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 962 template <typename T> 963 typename detail::enable_if<std::is_constructible<double, T>::value, Approx&>::type epsilon( 964 const T& newEpsilon) { 965 m_epsilon = static_cast<double>(newEpsilon); 966 return *this; 967 } 968#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 969 970 Approx& scale(double newScale); 971 972#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 973 template <typename T> 974 typename detail::enable_if<std::is_constructible<double, T>::value, Approx&>::type scale( 975 const T& newScale) { 976 m_scale = static_cast<double>(newScale); 977 return *this; 978 } 979#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 980 981 // clang-format off 982 DOCTEST_INTERFACE friend bool operator==(double lhs, const Approx & rhs); 983 DOCTEST_INTERFACE friend bool operator==(const Approx & lhs, double rhs); 984 DOCTEST_INTERFACE friend bool operator!=(double lhs, const Approx & rhs); 985 DOCTEST_INTERFACE friend bool operator!=(const Approx & lhs, double rhs); 986 DOCTEST_INTERFACE friend bool operator<=(double lhs, const Approx & rhs); 987 DOCTEST_INTERFACE friend bool operator<=(const Approx & lhs, double rhs); 988 DOCTEST_INTERFACE friend bool operator>=(double lhs, const Approx & rhs); 989 DOCTEST_INTERFACE friend bool operator>=(const Approx & lhs, double rhs); 990 DOCTEST_INTERFACE friend bool operator< (double lhs, const Approx & rhs); 991 DOCTEST_INTERFACE friend bool operator< (const Approx & lhs, double rhs); 992 DOCTEST_INTERFACE friend bool operator> (double lhs, const Approx & rhs); 993 DOCTEST_INTERFACE friend bool operator> (const Approx & lhs, double rhs); 994 995 DOCTEST_INTERFACE friend String toString(const Approx& in); 996 997#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 998#define DOCTEST_APPROX_PREFIX \ 999 template <typename T> friend typename detail::enable_if<std::is_constructible<double, T>::value, bool>::type 1000 1001 DOCTEST_APPROX_PREFIX operator==(const T& lhs, const Approx& rhs) { return operator==(double(lhs), rhs); } 1002 DOCTEST_APPROX_PREFIX operator==(const Approx& lhs, const T& rhs) { return operator==(rhs, lhs); } 1003 DOCTEST_APPROX_PREFIX operator!=(const T& lhs, const Approx& rhs) { return !operator==(lhs, rhs); } 1004 DOCTEST_APPROX_PREFIX operator!=(const Approx& lhs, const T& rhs) { return !operator==(rhs, lhs); } 1005 DOCTEST_APPROX_PREFIX operator<=(const T& lhs, const Approx& rhs) { return double(lhs) < rhs.m_value || lhs == rhs; } 1006 DOCTEST_APPROX_PREFIX operator<=(const Approx& lhs, const T& rhs) { return lhs.m_value < double(rhs) || lhs == rhs; } 1007 DOCTEST_APPROX_PREFIX operator>=(const T& lhs, const Approx& rhs) { return double(lhs) > rhs.m_value || lhs == rhs; } 1008 DOCTEST_APPROX_PREFIX operator>=(const Approx& lhs, const T& rhs) { return lhs.m_value > double(rhs) || lhs == rhs; } 1009 DOCTEST_APPROX_PREFIX operator< (const T& lhs, const Approx& rhs) { return double(lhs) < rhs.m_value && lhs != rhs; } 1010 DOCTEST_APPROX_PREFIX operator< (const Approx& lhs, const T& rhs) { return lhs.m_value < double(rhs) && lhs != rhs; } 1011 DOCTEST_APPROX_PREFIX operator> (const T& lhs, const Approx& rhs) { return double(lhs) > rhs.m_value && lhs != rhs; } 1012 DOCTEST_APPROX_PREFIX operator> (const Approx& lhs, const T& rhs) { return lhs.m_value > double(rhs) && lhs != rhs; } 1013#undef DOCTEST_APPROX_PREFIX 1014#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS 1015 1016 // clang-format on 1017 1018private: 1019 double m_epsilon; 1020 double m_scale; 1021 double m_value; 1022}; 1023 1024DOCTEST_INTERFACE String toString(const Approx& in); 1025 1026DOCTEST_INTERFACE const ContextOptions* getContextOptions(); 1027 1028#if !defined(DOCTEST_CONFIG_DISABLE) 1029 1030namespace detail { 1031 // clang-format off 1032#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1033 template<class T> struct decay_array { typedef T type; }; 1034 template<class T, unsigned N> struct decay_array<T[N]> { typedef T* type; }; 1035 template<class T> struct decay_array<T[]> { typedef T* type; }; 1036 1037 template<class T> struct not_char_pointer { enum { value = 1 }; }; 1038 template<> struct not_char_pointer<char*> { enum { value = 0 }; }; 1039 template<> struct not_char_pointer<const char*> { enum { value = 0 }; }; 1040 1041 template<class T> struct can_use_op : public not_char_pointer<typename decay_array<T>::type> {}; 1042#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1043 // clang-format on 1044 1045 struct DOCTEST_INTERFACE TestFailureException 1046 { 1047 }; 1048 1049 DOCTEST_INTERFACE bool checkIfShouldThrow(assertType::Enum at); 1050 1051#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 1052 DOCTEST_NORETURN 1053#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 1054 DOCTEST_INTERFACE void throwException(); 1055 1056 struct DOCTEST_INTERFACE Subcase 1057 { 1058 SubcaseSignature m_signature; 1059 bool m_entered = false; 1060 1061 Subcase(const String& name, const char* file, int line); 1062 ~Subcase(); 1063 1064 operator bool() const; 1065 }; 1066 1067 template <typename L, typename R> 1068 String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op, 1069 const DOCTEST_REF_WRAP(R) rhs) { 1070 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 1071 return toString(lhs) + op + toString(rhs); 1072 } 1073 1074#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0) 1075DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-comparison") 1076#endif 1077 1078// This will check if there is any way it could find a operator like member or friend and uses it. 1079// If not it doesn't find the operator or if the operator at global scope is defined after 1080// this template, the template won't be instantiated due to SFINAE. Once the template is not 1081// instantiated it can look for global operator using normal conversions. 1082#define SFINAE_OP(ret,op) decltype(doctest::detail::declval<L>() op doctest::detail::declval<R>(),static_cast<ret>(0)) 1083 1084#define DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(op, op_str, op_macro) \ 1085 template <typename R> \ 1086 DOCTEST_NOINLINE SFINAE_OP(Result,op) operator op(R&& rhs) { \ 1087 bool res = op_macro(doctest::detail::forward<L>(lhs), doctest::detail::forward<R>(rhs)); \ 1088 if(m_at & assertType::is_false) \ 1089 res = !res; \ 1090 if(!res || doctest::getContextOptions()->success) \ 1091 return Result(res, stringifyBinaryExpr(lhs, op_str, rhs)); \ 1092 return Result(res); \ 1093 } 1094 1095 // more checks could be added - like in Catch: 1096 // https://github.com/catchorg/Catch2/pull/1480/files 1097 // https://github.com/catchorg/Catch2/pull/1481/files 1098#define DOCTEST_FORBIT_EXPRESSION(rt, op) \ 1099 template <typename R> \ 1100 rt& operator op(const R&) { \ 1101 static_assert(deferred_false<R>::value, \ 1102 "Expression Too Complex Please Rewrite As Binary Comparison!"); \ 1103 return *this; \ 1104 } 1105 1106 struct DOCTEST_INTERFACE Result 1107 { 1108 bool m_passed; 1109 String m_decomp; 1110 1111 Result(bool passed, const String& decomposition = String()); 1112 1113 // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence 1114 DOCTEST_FORBIT_EXPRESSION(Result, &) 1115 DOCTEST_FORBIT_EXPRESSION(Result, ^) 1116 DOCTEST_FORBIT_EXPRESSION(Result, |) 1117 DOCTEST_FORBIT_EXPRESSION(Result, &&) 1118 DOCTEST_FORBIT_EXPRESSION(Result, ||) 1119 DOCTEST_FORBIT_EXPRESSION(Result, ==) 1120 DOCTEST_FORBIT_EXPRESSION(Result, !=) 1121 DOCTEST_FORBIT_EXPRESSION(Result, <) 1122 DOCTEST_FORBIT_EXPRESSION(Result, >) 1123 DOCTEST_FORBIT_EXPRESSION(Result, <=) 1124 DOCTEST_FORBIT_EXPRESSION(Result, >=) 1125 DOCTEST_FORBIT_EXPRESSION(Result, =) 1126 DOCTEST_FORBIT_EXPRESSION(Result, +=) 1127 DOCTEST_FORBIT_EXPRESSION(Result, -=) 1128 DOCTEST_FORBIT_EXPRESSION(Result, *=) 1129 DOCTEST_FORBIT_EXPRESSION(Result, /=) 1130 DOCTEST_FORBIT_EXPRESSION(Result, %=) 1131 DOCTEST_FORBIT_EXPRESSION(Result, <<=) 1132 DOCTEST_FORBIT_EXPRESSION(Result, >>=) 1133 DOCTEST_FORBIT_EXPRESSION(Result, &=) 1134 DOCTEST_FORBIT_EXPRESSION(Result, ^=) 1135 DOCTEST_FORBIT_EXPRESSION(Result, |=) 1136 }; 1137 1138#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION 1139 1140 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH 1141 DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion") 1142 DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-compare") 1143 //DOCTEST_CLANG_SUPPRESS_WARNING("-Wdouble-promotion") 1144 //DOCTEST_CLANG_SUPPRESS_WARNING("-Wconversion") 1145 //DOCTEST_CLANG_SUPPRESS_WARNING("-Wfloat-equal") 1146 1147 DOCTEST_GCC_SUPPRESS_WARNING_PUSH 1148 DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion") 1149 DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-compare") 1150 //DOCTEST_GCC_SUPPRESS_WARNING("-Wdouble-promotion") 1151 //DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion") 1152 //DOCTEST_GCC_SUPPRESS_WARNING("-Wfloat-equal") 1153 1154 DOCTEST_MSVC_SUPPRESS_WARNING_PUSH 1155 // https://stackoverflow.com/questions/39479163 what's the difference between 4018 and 4389 1156 DOCTEST_MSVC_SUPPRESS_WARNING(4388) // signed/unsigned mismatch 1157 DOCTEST_MSVC_SUPPRESS_WARNING(4389) // 'operator' : signed/unsigned mismatch 1158 DOCTEST_MSVC_SUPPRESS_WARNING(4018) // 'expression' : signed/unsigned mismatch 1159 //DOCTEST_MSVC_SUPPRESS_WARNING(4805) // 'operation' : unsafe mix of type 'type' and type 'type' in operation 1160 1161#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION 1162 1163 // clang-format off 1164#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1165#define DOCTEST_COMPARISON_RETURN_TYPE bool 1166#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1167#define DOCTEST_COMPARISON_RETURN_TYPE typename enable_if<can_use_op<L>::value || can_use_op<R>::value, bool>::type 1168 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 1169 inline bool eq(const char* lhs, const char* rhs) { return String(lhs) == String(rhs); } 1170 inline bool ne(const char* lhs, const char* rhs) { return String(lhs) != String(rhs); } 1171 inline bool lt(const char* lhs, const char* rhs) { return String(lhs) < String(rhs); } 1172 inline bool gt(const char* lhs, const char* rhs) { return String(lhs) > String(rhs); } 1173 inline bool le(const char* lhs, const char* rhs) { return String(lhs) <= String(rhs); } 1174 inline bool ge(const char* lhs, const char* rhs) { return String(lhs) >= String(rhs); } 1175#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1176 // clang-format on 1177 1178#define DOCTEST_RELATIONAL_OP(name, op) \ 1179 template <typename L, typename R> \ 1180 DOCTEST_COMPARISON_RETURN_TYPE name(const DOCTEST_REF_WRAP(L) lhs, \ 1181 const DOCTEST_REF_WRAP(R) rhs) { \ 1182 return lhs op rhs; \ 1183 } 1184 1185 DOCTEST_RELATIONAL_OP(eq, ==) 1186 DOCTEST_RELATIONAL_OP(ne, !=) 1187 DOCTEST_RELATIONAL_OP(lt, <) 1188 DOCTEST_RELATIONAL_OP(gt, >) 1189 DOCTEST_RELATIONAL_OP(le, <=) 1190 DOCTEST_RELATIONAL_OP(ge, >=) 1191 1192#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1193#define DOCTEST_CMP_EQ(l, r) l == r 1194#define DOCTEST_CMP_NE(l, r) l != r 1195#define DOCTEST_CMP_GT(l, r) l > r 1196#define DOCTEST_CMP_LT(l, r) l < r 1197#define DOCTEST_CMP_GE(l, r) l >= r 1198#define DOCTEST_CMP_LE(l, r) l <= r 1199#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1200#define DOCTEST_CMP_EQ(l, r) eq(l, r) 1201#define DOCTEST_CMP_NE(l, r) ne(l, r) 1202#define DOCTEST_CMP_GT(l, r) gt(l, r) 1203#define DOCTEST_CMP_LT(l, r) lt(l, r) 1204#define DOCTEST_CMP_GE(l, r) ge(l, r) 1205#define DOCTEST_CMP_LE(l, r) le(l, r) 1206#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1207 1208 template <typename L> 1209 // cppcheck-suppress copyCtorAndEqOperator 1210 struct Expression_lhs 1211 { 1212 L lhs; 1213 assertType::Enum m_at; 1214 1215 explicit Expression_lhs(L&& in, assertType::Enum at) 1216 : lhs(doctest::detail::forward<L>(in)) 1217 , m_at(at) {} 1218 1219 DOCTEST_NOINLINE operator Result() { 1220// this is needed only foc MSVC 2015: 1221// https://ci.appveyor.com/project/onqtam/doctest/builds/38181202 1222DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4800) // 'int': forcing value to bool 1223 bool res = static_cast<bool>(lhs); 1224DOCTEST_MSVC_SUPPRESS_WARNING_POP 1225 if(m_at & assertType::is_false) //!OCLINT bitwise operator in conditional 1226 res = !res; 1227 1228 if(!res || getContextOptions()->success) 1229 return Result(res, toString(lhs)); 1230 return Result(res); 1231 } 1232 1233 /* This is required for user-defined conversions from Expression_lhs to L */ 1234 //operator L() const { return lhs; } 1235 operator L() const { return lhs; } 1236 1237 // clang-format off 1238 DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(==, " == ", DOCTEST_CMP_EQ) //!OCLINT bitwise operator in conditional 1239 DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(!=, " != ", DOCTEST_CMP_NE) //!OCLINT bitwise operator in conditional 1240 DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>, " > ", DOCTEST_CMP_GT) //!OCLINT bitwise operator in conditional 1241 DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<, " < ", DOCTEST_CMP_LT) //!OCLINT bitwise operator in conditional 1242 DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>=, " >= ", DOCTEST_CMP_GE) //!OCLINT bitwise operator in conditional 1243 DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<=, " <= ", DOCTEST_CMP_LE) //!OCLINT bitwise operator in conditional 1244 // clang-format on 1245 1246 // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence 1247 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &) 1248 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^) 1249 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |) 1250 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &&) 1251 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ||) 1252 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, =) 1253 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, +=) 1254 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, -=) 1255 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, *=) 1256 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, /=) 1257 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, %=) 1258 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<=) 1259 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>=) 1260 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &=) 1261 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^=) 1262 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |=) 1263 // these 2 are unfortunate because they should be allowed - they have higher precedence over the comparisons, but the 1264 // ExpressionDecomposer class uses the left shift operator to capture the left operand of the binary expression... 1265 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<) 1266 DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>) 1267 }; 1268 1269#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION 1270 1271 DOCTEST_CLANG_SUPPRESS_WARNING_POP 1272 DOCTEST_MSVC_SUPPRESS_WARNING_POP 1273 DOCTEST_GCC_SUPPRESS_WARNING_POP 1274 1275#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION 1276 1277#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0) 1278DOCTEST_CLANG_SUPPRESS_WARNING_POP 1279#endif 1280 1281 struct DOCTEST_INTERFACE ExpressionDecomposer 1282 { 1283 assertType::Enum m_at; 1284 1285 ExpressionDecomposer(assertType::Enum at); 1286 1287 // The right operator for capturing expressions is "<=" instead of "<<" (based on the operator precedence table) 1288 // but then there will be warnings from GCC about "-Wparentheses" and since "_Pragma()" is problematic this will stay for now... 1289 // https://github.com/catchorg/Catch2/issues/870 1290 // https://github.com/catchorg/Catch2/issues/565 1291 template <typename L> 1292 Expression_lhs<L> operator<<(L &&operand) { 1293 return Expression_lhs<L>(doctest::detail::forward<L>(operand), m_at); 1294 } 1295 }; 1296 1297 struct DOCTEST_INTERFACE TestSuite 1298 { 1299 const char* m_test_suite; 1300 const char* m_description; 1301 bool m_skip; 1302 bool m_no_breaks; 1303 bool m_no_output; 1304 bool m_may_fail; 1305 bool m_should_fail; 1306 int m_expected_failures; 1307 double m_timeout; 1308 1309 TestSuite& operator*(const char* in); 1310 1311 template <typename T> 1312 TestSuite& operator*(const T& in) { 1313 in.fill(*this); 1314 return *this; 1315 } 1316 }; 1317 1318 typedef void (*funcType)(); 1319 1320 struct DOCTEST_INTERFACE TestCase : public TestCaseData 1321 { 1322 funcType m_test; // a function pointer to the test case 1323 1324 const char* m_type; // for templated test cases - gets appended to the real name 1325 int m_template_id; // an ID used to distinguish between the different versions of a templated test case 1326 String m_full_name; // contains the name (only for templated test cases!) + the template type 1327 1328 TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite, 1329 const char* type = "", int template_id = -1); 1330 1331 TestCase(const TestCase& other); 1332 1333 DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function 1334 TestCase& operator=(const TestCase& other); 1335 DOCTEST_MSVC_SUPPRESS_WARNING_POP 1336 1337 TestCase& operator*(const char* in); 1338 1339 template <typename T> 1340 TestCase& operator*(const T& in) { 1341 in.fill(*this); 1342 return *this; 1343 } 1344 1345 bool operator<(const TestCase& other) const; 1346 }; 1347 1348 // forward declarations of functions used by the macros 1349 DOCTEST_INTERFACE int regTest(const TestCase& tc); 1350 DOCTEST_INTERFACE int setTestSuite(const TestSuite& ts); 1351 DOCTEST_INTERFACE bool isDebuggerActive(); 1352 1353 template<typename T> 1354 int instantiationHelper(const T&) { return 0; } 1355 1356 namespace binaryAssertComparison { 1357 enum Enum 1358 { 1359 eq = 0, 1360 ne, 1361 gt, 1362 lt, 1363 ge, 1364 le 1365 }; 1366 } // namespace binaryAssertComparison 1367 1368 // clang-format off 1369 template <int, class L, class R> struct RelationalComparator { bool operator()(const DOCTEST_REF_WRAP(L), const DOCTEST_REF_WRAP(R) ) const { return false; } }; 1370 1371#define DOCTEST_BINARY_RELATIONAL_OP(n, op) \ 1372 template <class L, class R> struct RelationalComparator<n, L, R> { bool operator()(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) const { return op(lhs, rhs); } }; 1373 // clang-format on 1374 1375 DOCTEST_BINARY_RELATIONAL_OP(0, doctest::detail::eq) 1376 DOCTEST_BINARY_RELATIONAL_OP(1, doctest::detail::ne) 1377 DOCTEST_BINARY_RELATIONAL_OP(2, doctest::detail::gt) 1378 DOCTEST_BINARY_RELATIONAL_OP(3, doctest::detail::lt) 1379 DOCTEST_BINARY_RELATIONAL_OP(4, doctest::detail::ge) 1380 DOCTEST_BINARY_RELATIONAL_OP(5, doctest::detail::le) 1381 1382 struct DOCTEST_INTERFACE ResultBuilder : public AssertData 1383 { 1384 ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr, 1385 const char* exception_type = "", const char* exception_string = ""); 1386 1387 void setResult(const Result& res); 1388 1389 template <int comparison, typename L, typename R> 1390 DOCTEST_NOINLINE void binary_assert(const DOCTEST_REF_WRAP(L) lhs, 1391 const DOCTEST_REF_WRAP(R) rhs) { 1392 m_failed = !RelationalComparator<comparison, L, R>()(lhs, rhs); 1393 if(m_failed || getContextOptions()->success) 1394 m_decomp = stringifyBinaryExpr(lhs, ", ", rhs); 1395 } 1396 1397 template <typename L> 1398 DOCTEST_NOINLINE void unary_assert(const DOCTEST_REF_WRAP(L) val) { 1399 m_failed = !val; 1400 1401 if(m_at & assertType::is_false) //!OCLINT bitwise operator in conditional 1402 m_failed = !m_failed; 1403 1404 if(m_failed || getContextOptions()->success) 1405 m_decomp = toString(val); 1406 } 1407 1408 void translateException(); 1409 1410 bool log(); 1411 void react() const; 1412 }; 1413 1414 namespace assertAction { 1415 enum Enum 1416 { 1417 nothing = 0, 1418 dbgbreak = 1, 1419 shouldthrow = 2 1420 }; 1421 } // namespace assertAction 1422 1423 DOCTEST_INTERFACE void failed_out_of_a_testing_context(const AssertData& ad); 1424 1425 DOCTEST_INTERFACE void decomp_assert(assertType::Enum at, const char* file, int line, 1426 const char* expr, Result result); 1427 1428#define DOCTEST_ASSERT_OUT_OF_TESTS(decomp) \ 1429 do { \ 1430 if(!is_running_in_test) { \ 1431 if(failed) { \ 1432 ResultBuilder rb(at, file, line, expr); \ 1433 rb.m_failed = failed; \ 1434 rb.m_decomp = decomp; \ 1435 failed_out_of_a_testing_context(rb); \ 1436 if(isDebuggerActive() && !getContextOptions()->no_breaks) \ 1437 DOCTEST_BREAK_INTO_DEBUGGER(); \ 1438 if(checkIfShouldThrow(at)) \ 1439 throwException(); \ 1440 } \ 1441 return; \ 1442 } \ 1443 } while(false) 1444 1445#define DOCTEST_ASSERT_IN_TESTS(decomp) \ 1446 ResultBuilder rb(at, file, line, expr); \ 1447 rb.m_failed = failed; \ 1448 if(rb.m_failed || getContextOptions()->success) \ 1449 rb.m_decomp = decomp; \ 1450 if(rb.log()) \ 1451 DOCTEST_BREAK_INTO_DEBUGGER(); \ 1452 if(rb.m_failed && checkIfShouldThrow(at)) \ 1453 throwException() 1454 1455 template <int comparison, typename L, typename R> 1456 DOCTEST_NOINLINE void binary_assert(assertType::Enum at, const char* file, int line, 1457 const char* expr, const DOCTEST_REF_WRAP(L) lhs, 1458 const DOCTEST_REF_WRAP(R) rhs) { 1459 bool failed = !RelationalComparator<comparison, L, R>()(lhs, rhs); 1460 1461 // ################################################################################### 1462 // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT 1463 // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED 1464 // ################################################################################### 1465 DOCTEST_ASSERT_OUT_OF_TESTS(stringifyBinaryExpr(lhs, ", ", rhs)); 1466 DOCTEST_ASSERT_IN_TESTS(stringifyBinaryExpr(lhs, ", ", rhs)); 1467 } 1468 1469 template <typename L> 1470 DOCTEST_NOINLINE void unary_assert(assertType::Enum at, const char* file, int line, 1471 const char* expr, const DOCTEST_REF_WRAP(L) val) { 1472 bool failed = !val; 1473 1474 if(at & assertType::is_false) //!OCLINT bitwise operator in conditional 1475 failed = !failed; 1476 1477 // ################################################################################### 1478 // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT 1479 // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED 1480 // ################################################################################### 1481 DOCTEST_ASSERT_OUT_OF_TESTS(toString(val)); 1482 DOCTEST_ASSERT_IN_TESTS(toString(val)); 1483 } 1484 1485 struct DOCTEST_INTERFACE IExceptionTranslator 1486 { 1487 IExceptionTranslator(); 1488 virtual ~IExceptionTranslator(); 1489 virtual bool translate(String&) const = 0; 1490 }; 1491 1492 template <typename T> 1493 class ExceptionTranslator : public IExceptionTranslator //!OCLINT destructor of virtual class 1494 { 1495 public: 1496 explicit ExceptionTranslator(String (*translateFunction)(T)) 1497 : m_translateFunction(translateFunction) {} 1498 1499 bool translate(String& res) const override { 1500#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 1501 try { 1502 throw; // lgtm [cpp/rethrow-no-exception] 1503 // cppcheck-suppress catchExceptionByValue 1504 } catch(T ex) { // NOLINT 1505 res = m_translateFunction(ex); //!OCLINT parameter reassignment 1506 return true; 1507 } catch(...) {} //!OCLINT - empty catch statement 1508#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 1509 static_cast<void>(res); // to silence -Wunused-parameter 1510 return false; 1511 } 1512 1513 private: 1514 String (*m_translateFunction)(T); 1515 }; 1516 1517 DOCTEST_INTERFACE void registerExceptionTranslatorImpl(const IExceptionTranslator* et); 1518 1519 template <bool C> 1520 struct StringStreamBase 1521 { 1522 template <typename T> 1523 static void convert(std::ostream* s, const T& in) { 1524 *s << toString(in); 1525 } 1526 1527 // always treat char* as a string in this context - no matter 1528 // if DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING is defined 1529 static void convert(std::ostream* s, const char* in) { *s << String(in); } 1530 }; 1531 1532 template <> 1533 struct StringStreamBase<true> 1534 { 1535 template <typename T> 1536 static void convert(std::ostream* s, const T& in) { 1537 *s << in; 1538 } 1539 }; 1540 1541 template <typename T> 1542 struct StringStream : public StringStreamBase<has_insertion_operator<T>::value> 1543 {}; 1544 1545 template <typename T> 1546 void toStream(std::ostream* s, const T& value) { 1547 StringStream<T>::convert(s, value); 1548 } 1549 1550#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1551 DOCTEST_INTERFACE void toStream(std::ostream* s, char* in); 1552 DOCTEST_INTERFACE void toStream(std::ostream* s, const char* in); 1553#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 1554 DOCTEST_INTERFACE void toStream(std::ostream* s, bool in); 1555 DOCTEST_INTERFACE void toStream(std::ostream* s, float in); 1556 DOCTEST_INTERFACE void toStream(std::ostream* s, double in); 1557 DOCTEST_INTERFACE void toStream(std::ostream* s, double long in); 1558 1559 DOCTEST_INTERFACE void toStream(std::ostream* s, char in); 1560 DOCTEST_INTERFACE void toStream(std::ostream* s, char signed in); 1561 DOCTEST_INTERFACE void toStream(std::ostream* s, char unsigned in); 1562 DOCTEST_INTERFACE void toStream(std::ostream* s, int short in); 1563 DOCTEST_INTERFACE void toStream(std::ostream* s, int short unsigned in); 1564 DOCTEST_INTERFACE void toStream(std::ostream* s, int in); 1565 DOCTEST_INTERFACE void toStream(std::ostream* s, int unsigned in); 1566 DOCTEST_INTERFACE void toStream(std::ostream* s, int long in); 1567 DOCTEST_INTERFACE void toStream(std::ostream* s, int long unsigned in); 1568 DOCTEST_INTERFACE void toStream(std::ostream* s, int long long in); 1569 DOCTEST_INTERFACE void toStream(std::ostream* s, int long long unsigned in); 1570 1571 // ContextScope base class used to allow implementing methods of ContextScope 1572 // that don't depend on the template parameter in doctest.cpp. 1573 class DOCTEST_INTERFACE ContextScopeBase : public IContextScope { 1574 protected: 1575 ContextScopeBase(); 1576 1577 void destroy(); 1578 }; 1579 1580 template <typename L> class ContextScope : public ContextScopeBase 1581 { 1582 const L lambda_; 1583 1584 public: 1585 explicit ContextScope(const L &lambda) : lambda_(lambda) {} 1586 1587 ContextScope(ContextScope &&other) : lambda_(other.lambda_) {} 1588 1589 void stringify(std::ostream* s) const override { lambda_(s); } 1590 1591 ~ContextScope() override { destroy(); } 1592 }; 1593 1594 struct DOCTEST_INTERFACE MessageBuilder : public MessageData 1595 { 1596 std::ostream* m_stream; 1597 1598 MessageBuilder(const char* file, int line, assertType::Enum severity); 1599 MessageBuilder() = delete; 1600 ~MessageBuilder(); 1601 1602 // the preferred way of chaining parameters for stringification 1603 template <typename T> 1604 MessageBuilder& operator,(const T& in) { 1605 toStream(m_stream, in); 1606 return *this; 1607 } 1608 1609 // kept here just for backwards-compatibility - the comma operator should be preferred now 1610 template <typename T> 1611 MessageBuilder& operator<<(const T& in) { return this->operator,(in); } 1612 1613 // the `,` operator has the lowest operator precedence - if `<<` is used by the user then 1614 // the `,` operator will be called last which is not what we want and thus the `*` operator 1615 // is used first (has higher operator precedence compared to `<<`) so that we guarantee that 1616 // an operator of the MessageBuilder class is called first before the rest of the parameters 1617 template <typename T> 1618 MessageBuilder& operator*(const T& in) { return this->operator,(in); } 1619 1620 bool log(); 1621 void react(); 1622 }; 1623 1624 template <typename L> 1625 ContextScope<L> MakeContextScope(const L &lambda) { 1626 return ContextScope<L>(lambda); 1627 } 1628} // namespace detail 1629 1630#define DOCTEST_DEFINE_DECORATOR(name, type, def) \ 1631 struct name \ 1632 { \ 1633 type data; \ 1634 name(type in = def) \ 1635 : data(in) {} \ 1636 void fill(detail::TestCase& state) const { state.DOCTEST_CAT(m_, name) = data; } \ 1637 void fill(detail::TestSuite& state) const { state.DOCTEST_CAT(m_, name) = data; } \ 1638 } 1639 1640DOCTEST_DEFINE_DECORATOR(test_suite, const char*, ""); 1641DOCTEST_DEFINE_DECORATOR(description, const char*, ""); 1642DOCTEST_DEFINE_DECORATOR(skip, bool, true); 1643DOCTEST_DEFINE_DECORATOR(no_breaks, bool, true); 1644DOCTEST_DEFINE_DECORATOR(no_output, bool, true); 1645DOCTEST_DEFINE_DECORATOR(timeout, double, 0); 1646DOCTEST_DEFINE_DECORATOR(may_fail, bool, true); 1647DOCTEST_DEFINE_DECORATOR(should_fail, bool, true); 1648DOCTEST_DEFINE_DECORATOR(expected_failures, int, 0); 1649 1650template <typename T> 1651int registerExceptionTranslator(String (*translateFunction)(T)) { 1652 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors") 1653 static detail::ExceptionTranslator<T> exceptionTranslator(translateFunction); 1654 DOCTEST_CLANG_SUPPRESS_WARNING_POP 1655 detail::registerExceptionTranslatorImpl(&exceptionTranslator); 1656 return 0; 1657} 1658 1659} // namespace doctest 1660 1661// in a separate namespace outside of doctest because the DOCTEST_TEST_SUITE macro 1662// introduces an anonymous namespace in which getCurrentTestSuite gets overridden 1663namespace doctest_detail_test_suite_ns { 1664DOCTEST_INTERFACE doctest::detail::TestSuite& getCurrentTestSuite(); 1665} // namespace doctest_detail_test_suite_ns 1666 1667namespace doctest { 1668#else // DOCTEST_CONFIG_DISABLE 1669template <typename T> 1670int registerExceptionTranslator(String (*)(T)) { 1671 return 0; 1672} 1673#endif // DOCTEST_CONFIG_DISABLE 1674 1675namespace detail { 1676 typedef void (*assert_handler)(const AssertData&); 1677 struct ContextState; 1678} // namespace detail 1679 1680class DOCTEST_INTERFACE Context 1681{ 1682 detail::ContextState* p; 1683 1684 void parseArgs(int argc, const char* const* argv, bool withDefaults = false); 1685 1686public: 1687 explicit Context(int argc = 0, const char* const* argv = nullptr); 1688 1689 ~Context(); 1690 1691 void applyCommandLine(int argc, const char* const* argv); 1692 1693 void addFilter(const char* filter, const char* value); 1694 void clearFilters(); 1695 void setOption(const char* option, int value); 1696 void setOption(const char* option, const char* value); 1697 1698 bool shouldExit(); 1699 1700 void setAsDefaultForAssertsOutOfTestCases(); 1701 1702 void setAssertHandler(detail::assert_handler ah); 1703 1704 int run(); 1705}; 1706 1707namespace TestCaseFailureReason { 1708 enum Enum 1709 { 1710 None = 0, 1711 AssertFailure = 1, // an assertion has failed in the test case 1712 Exception = 2, // test case threw an exception 1713 Crash = 4, // a crash... 1714 TooManyFailedAsserts = 8, // the abort-after option 1715 Timeout = 16, // see the timeout decorator 1716 ShouldHaveFailedButDidnt = 32, // see the should_fail decorator 1717 ShouldHaveFailedAndDid = 64, // see the should_fail decorator 1718 DidntFailExactlyNumTimes = 128, // see the expected_failures decorator 1719 FailedExactlyNumTimes = 256, // see the expected_failures decorator 1720 CouldHaveFailedAndDid = 512 // see the may_fail decorator 1721 }; 1722} // namespace TestCaseFailureReason 1723 1724struct DOCTEST_INTERFACE CurrentTestCaseStats 1725{ 1726 int numAssertsCurrentTest; 1727 int numAssertsFailedCurrentTest; 1728 double seconds; 1729 int failure_flags; // use TestCaseFailureReason::Enum 1730}; 1731 1732struct DOCTEST_INTERFACE TestCaseException 1733{ 1734 String error_string; 1735 bool is_crash; 1736}; 1737 1738struct DOCTEST_INTERFACE TestRunStats 1739{ 1740 unsigned numTestCases; 1741 unsigned numTestCasesPassingFilters; 1742 unsigned numTestSuitesPassingFilters; 1743 unsigned numTestCasesFailed; 1744 int numAsserts; 1745 int numAssertsFailed; 1746}; 1747 1748struct QueryData 1749{ 1750 const TestRunStats* run_stats = nullptr; 1751 const TestCaseData** data = nullptr; 1752 unsigned num_data = 0; 1753}; 1754 1755struct DOCTEST_INTERFACE IReporter 1756{ 1757 // The constructor has to accept "const ContextOptions&" as a single argument 1758 // which has most of the options for the run + a pointer to the stdout stream 1759 // Reporter(const ContextOptions& in) 1760 1761 // called when a query should be reported (listing test cases, printing the version, etc.) 1762 virtual void report_query(const QueryData&) = 0; 1763 1764 // called when the whole test run starts 1765 virtual void test_run_start() = 0; 1766 // called when the whole test run ends (caching a pointer to the input doesn't make sense here) 1767 virtual void test_run_end(const TestRunStats&) = 0; 1768 1769 // called when a test case is started (safe to cache a pointer to the input) 1770 virtual void test_case_start(const TestCaseData&) = 0; 1771 // called when a test case is reentered because of unfinished subcases (safe to cache a pointer to the input) 1772 virtual void test_case_reenter(const TestCaseData&) = 0; 1773 // called when a test case has ended 1774 virtual void test_case_end(const CurrentTestCaseStats&) = 0; 1775 1776 // called when an exception is thrown from the test case (or it crashes) 1777 virtual void test_case_exception(const TestCaseException&) = 0; 1778 1779 // called whenever a subcase is entered (don't cache pointers to the input) 1780 virtual void subcase_start(const SubcaseSignature&) = 0; 1781 // called whenever a subcase is exited (don't cache pointers to the input) 1782 virtual void subcase_end() = 0; 1783 1784 // called for each assert (don't cache pointers to the input) 1785 virtual void log_assert(const AssertData&) = 0; 1786 // called for each message (don't cache pointers to the input) 1787 virtual void log_message(const MessageData&) = 0; 1788 1789 // called when a test case is skipped either because it doesn't pass the filters, has a skip decorator 1790 // or isn't in the execution range (between first and last) (safe to cache a pointer to the input) 1791 virtual void test_case_skipped(const TestCaseData&) = 0; 1792 1793 // doctest will not be managing the lifetimes of reporters given to it but this would still be nice to have 1794 virtual ~IReporter(); 1795 1796 // can obtain all currently active contexts and stringify them if one wishes to do so 1797 static int get_num_active_contexts(); 1798 static const IContextScope* const* get_active_contexts(); 1799 1800 // can iterate through contexts which have been stringified automatically in their destructors when an exception has been thrown 1801 static int get_num_stringified_contexts(); 1802 static const String* get_stringified_contexts(); 1803}; 1804 1805namespace detail { 1806 typedef IReporter* (*reporterCreatorFunc)(const ContextOptions&); 1807 1808 DOCTEST_INTERFACE void registerReporterImpl(const char* name, int prio, reporterCreatorFunc c, bool isReporter); 1809 1810 template <typename Reporter> 1811 IReporter* reporterCreator(const ContextOptions& o) { 1812 return new Reporter(o); 1813 } 1814} // namespace detail 1815 1816template <typename Reporter> 1817int registerReporter(const char* name, int priority, bool isReporter) { 1818 detail::registerReporterImpl(name, priority, detail::reporterCreator<Reporter>, isReporter); 1819 return 0; 1820} 1821} // namespace doctest 1822 1823// if registering is not disabled 1824#if !defined(DOCTEST_CONFIG_DISABLE) 1825 1826// common code in asserts - for convenience 1827#define DOCTEST_ASSERT_LOG_AND_REACT(b) \ 1828 if(b.log()) \ 1829 DOCTEST_BREAK_INTO_DEBUGGER(); \ 1830 b.react() 1831 1832#ifdef DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS 1833#define DOCTEST_WRAP_IN_TRY(x) x; 1834#else // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS 1835#define DOCTEST_WRAP_IN_TRY(x) \ 1836 try { \ 1837 x; \ 1838 } catch(...) { _DOCTEST_RB.translateException(); } 1839#endif // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS 1840 1841#ifdef DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS 1842#define DOCTEST_CAST_TO_VOID(...) \ 1843 DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wuseless-cast") \ 1844 static_cast<void>(__VA_ARGS__); \ 1845 DOCTEST_GCC_SUPPRESS_WARNING_POP 1846#else // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS 1847#define DOCTEST_CAST_TO_VOID(...) __VA_ARGS__; 1848#endif // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS 1849 1850// registers the test by initializing a dummy var with a function 1851#define DOCTEST_REGISTER_FUNCTION(global_prefix, f, decorators) \ 1852 global_prefix DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) = \ 1853 doctest::detail::regTest( \ 1854 doctest::detail::TestCase( \ 1855 f, __FILE__, __LINE__, \ 1856 doctest_detail_test_suite_ns::getCurrentTestSuite()) * \ 1857 decorators); \ 1858 DOCTEST_GLOBAL_NO_WARNINGS_END() 1859 1860#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, decorators) \ 1861 namespace { \ 1862 struct der : public base \ 1863 { \ 1864 void f(); \ 1865 }; \ 1866 static void func() { \ 1867 der v; \ 1868 v.f(); \ 1869 } \ 1870 DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, func, decorators) \ 1871 } \ 1872 inline DOCTEST_NOINLINE void der::f() 1873 1874#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, decorators) \ 1875 static void f(); \ 1876 DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, f, decorators) \ 1877 static void f() 1878 1879#define DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(f, proxy, decorators) \ 1880 static doctest::detail::funcType proxy() { return f; } \ 1881 DOCTEST_REGISTER_FUNCTION(inline const, proxy(), decorators) \ 1882 static void f() 1883 1884// for registering tests 1885#define DOCTEST_TEST_CASE(decorators) \ 1886 DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), decorators) 1887 1888// for registering tests in classes - requires C++17 for inline variables! 1889#if __cplusplus >= 201703L || (DOCTEST_MSVC >= DOCTEST_COMPILER(19, 12, 0) && _MSVC_LANG >= 201703L) 1890#define DOCTEST_TEST_CASE_CLASS(decorators) \ 1891 DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), \ 1892 DOCTEST_ANONYMOUS(_DOCTEST_ANON_PROXY_), \ 1893 decorators) 1894#else // DOCTEST_TEST_CASE_CLASS 1895#define DOCTEST_TEST_CASE_CLASS(...) \ 1896 TEST_CASES_CAN_BE_REGISTERED_IN_CLASSES_ONLY_IN_CPP17_MODE_OR_WITH_VS_2017_OR_NEWER 1897#endif // DOCTEST_TEST_CASE_CLASS 1898 1899// for registering tests with a fixture 1900#define DOCTEST_TEST_CASE_FIXTURE(c, decorators) \ 1901 DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(_DOCTEST_ANON_CLASS_), c, \ 1902 DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), decorators) 1903 1904// for converting types to strings without the <typeinfo> header and demangling 1905#define DOCTEST_TYPE_TO_STRING_IMPL(...) \ 1906 template <> \ 1907 inline const char* type_to_string<__VA_ARGS__>() { \ 1908 return "<" #__VA_ARGS__ ">"; \ 1909 } 1910#define DOCTEST_TYPE_TO_STRING(...) \ 1911 namespace doctest { namespace detail { \ 1912 DOCTEST_TYPE_TO_STRING_IMPL(__VA_ARGS__) \ 1913 } \ 1914 } \ 1915 typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 1916 1917#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, iter, func) \ 1918 template <typename T> \ 1919 static void func(); \ 1920 namespace { \ 1921 template <typename Tuple> \ 1922 struct iter; \ 1923 template <typename Type, typename... Rest> \ 1924 struct iter<std::tuple<Type, Rest...>> \ 1925 { \ 1926 iter(const char* file, unsigned line, int index) { \ 1927 doctest::detail::regTest(doctest::detail::TestCase(func<Type>, file, line, \ 1928 doctest_detail_test_suite_ns::getCurrentTestSuite(), \ 1929 doctest::detail::type_to_string<Type>(), \ 1930 int(line) * 1000 + index) \ 1931 * dec); \ 1932 iter<std::tuple<Rest...>>(file, line, index + 1); \ 1933 } \ 1934 }; \ 1935 template <> \ 1936 struct iter<std::tuple<>> \ 1937 { \ 1938 iter(const char*, unsigned, int) {} \ 1939 }; \ 1940 } \ 1941 template <typename T> \ 1942 static void func() 1943 1944#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(dec, T, id) \ 1945 DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(id, ITERATOR), \ 1946 DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)) 1947 1948#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, anon, ...) \ 1949 DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_CAT(anon, DUMMY)) = \ 1950 doctest::detail::instantiationHelper(DOCTEST_CAT(id, ITERATOR)<__VA_ARGS__>(__FILE__, __LINE__, 0));\ 1951 DOCTEST_GLOBAL_NO_WARNINGS_END() 1952 1953#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...) \ 1954 DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_), std::tuple<__VA_ARGS__>) \ 1955 typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 1956 1957#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...) \ 1958 DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_), __VA_ARGS__) \ 1959 typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 1960 1961#define DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, anon, ...) \ 1962 DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(anon, ITERATOR), anon); \ 1963 DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(anon, anon, std::tuple<__VA_ARGS__>) \ 1964 template <typename T> \ 1965 static void anon() 1966 1967#define DOCTEST_TEST_CASE_TEMPLATE(dec, T, ...) \ 1968 DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_), __VA_ARGS__) 1969 1970// for subcases 1971#define DOCTEST_SUBCASE(name) \ 1972 if(const doctest::detail::Subcase & DOCTEST_ANONYMOUS(_DOCTEST_ANON_SUBCASE_) DOCTEST_UNUSED = \ 1973 doctest::detail::Subcase(name, __FILE__, __LINE__)) 1974 1975// for grouping tests in test suites by using code blocks 1976#define DOCTEST_TEST_SUITE_IMPL(decorators, ns_name) \ 1977 namespace ns_name { namespace doctest_detail_test_suite_ns { \ 1978 static DOCTEST_NOINLINE doctest::detail::TestSuite& getCurrentTestSuite() { \ 1979 DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4640) \ 1980 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors") \ 1981 DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmissing-field-initializers") \ 1982 static doctest::detail::TestSuite data{}; \ 1983 static bool inited = false; \ 1984 DOCTEST_MSVC_SUPPRESS_WARNING_POP \ 1985 DOCTEST_CLANG_SUPPRESS_WARNING_POP \ 1986 DOCTEST_GCC_SUPPRESS_WARNING_POP \ 1987 if(!inited) { \ 1988 data* decorators; \ 1989 inited = true; \ 1990 } \ 1991 return data; \ 1992 } \ 1993 } \ 1994 } \ 1995 namespace ns_name 1996 1997#define DOCTEST_TEST_SUITE(decorators) \ 1998 DOCTEST_TEST_SUITE_IMPL(decorators, DOCTEST_ANONYMOUS(_DOCTEST_ANON_SUITE_)) 1999 2000// for starting a testsuite block 2001#define DOCTEST_TEST_SUITE_BEGIN(decorators) \ 2002 DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) = \ 2003 doctest::detail::setTestSuite(doctest::detail::TestSuite() * decorators); \ 2004 DOCTEST_GLOBAL_NO_WARNINGS_END() \ 2005 typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2006 2007// for ending a testsuite block 2008#define DOCTEST_TEST_SUITE_END \ 2009 DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_VAR_)) = \ 2010 doctest::detail::setTestSuite(doctest::detail::TestSuite() * ""); \ 2011 DOCTEST_GLOBAL_NO_WARNINGS_END() \ 2012 typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2013 2014// for registering exception translators 2015#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(translatorName, signature) \ 2016 inline doctest::String translatorName(signature); \ 2017 DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_)) = \ 2018 doctest::registerExceptionTranslator(translatorName); \ 2019 DOCTEST_GLOBAL_NO_WARNINGS_END() \ 2020 doctest::String translatorName(signature) 2021 2022#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature) \ 2023 DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_), \ 2024 signature) 2025 2026// for registering reporters 2027#define DOCTEST_REGISTER_REPORTER(name, priority, reporter) \ 2028 DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_REPORTER_)) = \ 2029 doctest::registerReporter<reporter>(name, priority, true); \ 2030 DOCTEST_GLOBAL_NO_WARNINGS_END() typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2031 2032// for registering listeners 2033#define DOCTEST_REGISTER_LISTENER(name, priority, reporter) \ 2034 DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(_DOCTEST_ANON_REPORTER_)) = \ 2035 doctest::registerReporter<reporter>(name, priority, false); \ 2036 DOCTEST_GLOBAL_NO_WARNINGS_END() typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2037 2038// for logging 2039#define DOCTEST_INFO(...) \ 2040 DOCTEST_INFO_IMPL(DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_), DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_), \ 2041 __VA_ARGS__) 2042 2043#define DOCTEST_INFO_IMPL(mb_name, s_name, ...) \ 2044 auto DOCTEST_ANONYMOUS(_DOCTEST_CAPTURE_) = doctest::detail::MakeContextScope( \ 2045 [&](std::ostream* s_name) { \ 2046 doctest::detail::MessageBuilder mb_name(__FILE__, __LINE__, doctest::assertType::is_warn); \ 2047 mb_name.m_stream = s_name; \ 2048 mb_name * __VA_ARGS__; \ 2049 }) 2050 2051#define DOCTEST_CAPTURE(x) DOCTEST_INFO(#x " := ", x) 2052 2053#define DOCTEST_ADD_AT_IMPL(type, file, line, mb, ...) \ 2054 do { \ 2055 doctest::detail::MessageBuilder mb(file, line, doctest::assertType::type); \ 2056 mb * __VA_ARGS__; \ 2057 DOCTEST_ASSERT_LOG_AND_REACT(mb); \ 2058 } while(false) 2059 2060// clang-format off 2061#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_warn, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), __VA_ARGS__) 2062#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_check, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), __VA_ARGS__) 2063#define DOCTEST_ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_require, file, line, DOCTEST_ANONYMOUS(_DOCTEST_MESSAGE_), __VA_ARGS__) 2064// clang-format on 2065 2066#define DOCTEST_MESSAGE(...) DOCTEST_ADD_MESSAGE_AT(__FILE__, __LINE__, __VA_ARGS__) 2067#define DOCTEST_FAIL_CHECK(...) DOCTEST_ADD_FAIL_CHECK_AT(__FILE__, __LINE__, __VA_ARGS__) 2068#define DOCTEST_FAIL(...) DOCTEST_ADD_FAIL_AT(__FILE__, __LINE__, __VA_ARGS__) 2069 2070#define DOCTEST_TO_LVALUE(...) __VA_ARGS__ // Not removed to keep backwards compatibility. 2071 2072#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS 2073 2074#define DOCTEST_ASSERT_IMPLEMENT_2(assert_type, ...) \ 2075 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses") \ 2076 doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \ 2077 __LINE__, #__VA_ARGS__); \ 2078 DOCTEST_WRAP_IN_TRY(_DOCTEST_RB.setResult( \ 2079 doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type) \ 2080 << __VA_ARGS__)) \ 2081 DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB) \ 2082 DOCTEST_CLANG_SUPPRESS_WARNING_POP 2083 2084#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...) \ 2085 do { \ 2086 DOCTEST_ASSERT_IMPLEMENT_2(assert_type, __VA_ARGS__); \ 2087 } while(false) 2088 2089#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS 2090 2091// necessary for <ASSERT>_MESSAGE 2092#define DOCTEST_ASSERT_IMPLEMENT_2 DOCTEST_ASSERT_IMPLEMENT_1 2093 2094#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...) \ 2095 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses") \ 2096 doctest::detail::decomp_assert( \ 2097 doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__, \ 2098 doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type) \ 2099 << __VA_ARGS__) DOCTEST_CLANG_SUPPRESS_WARNING_POP 2100 2101#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS 2102 2103#define DOCTEST_WARN(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN, __VA_ARGS__) 2104#define DOCTEST_CHECK(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK, __VA_ARGS__) 2105#define DOCTEST_REQUIRE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE, __VA_ARGS__) 2106#define DOCTEST_WARN_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN_FALSE, __VA_ARGS__) 2107#define DOCTEST_CHECK_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK_FALSE, __VA_ARGS__) 2108#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE_FALSE, __VA_ARGS__) 2109 2110// clang-format off 2111#define DOCTEST_WARN_MESSAGE(cond, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN, cond); } while(false) 2112#define DOCTEST_CHECK_MESSAGE(cond, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK, cond); } while(false) 2113#define DOCTEST_REQUIRE_MESSAGE(cond, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE, cond); } while(false) 2114#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN_FALSE, cond); } while(false) 2115#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK_FALSE, cond); } while(false) 2116#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE_FALSE, cond); } while(false) 2117// clang-format on 2118 2119#define DOCTEST_ASSERT_THROWS_AS(expr, assert_type, message, ...) \ 2120 do { \ 2121 if(!doctest::getContextOptions()->no_throw) { \ 2122 doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \ 2123 __LINE__, #expr, #__VA_ARGS__, message); \ 2124 try { \ 2125 DOCTEST_CAST_TO_VOID(expr) \ 2126 } catch(const typename doctest::detail::remove_const< \ 2127 typename doctest::detail::remove_reference<__VA_ARGS__>::type>::type&) { \ 2128 _DOCTEST_RB.translateException(); \ 2129 _DOCTEST_RB.m_threw_as = true; \ 2130 } catch(...) { _DOCTEST_RB.translateException(); } \ 2131 DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ 2132 } \ 2133 } while(false) 2134 2135#define DOCTEST_ASSERT_THROWS_WITH(expr, expr_str, assert_type, ...) \ 2136 do { \ 2137 if(!doctest::getContextOptions()->no_throw) { \ 2138 doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \ 2139 __LINE__, expr_str, "", __VA_ARGS__); \ 2140 try { \ 2141 DOCTEST_CAST_TO_VOID(expr) \ 2142 } catch(...) { _DOCTEST_RB.translateException(); } \ 2143 DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ 2144 } \ 2145 } while(false) 2146 2147#define DOCTEST_ASSERT_NOTHROW(assert_type, ...) \ 2148 do { \ 2149 doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \ 2150 __LINE__, #__VA_ARGS__); \ 2151 try { \ 2152 DOCTEST_CAST_TO_VOID(__VA_ARGS__) \ 2153 } catch(...) { _DOCTEST_RB.translateException(); } \ 2154 DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ 2155 } while(false) 2156 2157// clang-format off 2158#define DOCTEST_WARN_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_WARN_THROWS, "") 2159#define DOCTEST_CHECK_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_CHECK_THROWS, "") 2160#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_REQUIRE_THROWS, "") 2161 2162#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_AS, "", __VA_ARGS__) 2163#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_AS, "", __VA_ARGS__) 2164#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_AS, "", __VA_ARGS__) 2165 2166#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_WARN_THROWS_WITH, __VA_ARGS__) 2167#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_CHECK_THROWS_WITH, __VA_ARGS__) 2168#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_REQUIRE_THROWS_WITH, __VA_ARGS__) 2169 2170#define DOCTEST_WARN_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_WITH_AS, message, __VA_ARGS__) 2171#define DOCTEST_CHECK_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_WITH_AS, message, __VA_ARGS__) 2172#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_WITH_AS, message, __VA_ARGS__) 2173 2174#define DOCTEST_WARN_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_WARN_NOTHROW, __VA_ARGS__) 2175#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_CHECK_NOTHROW, __VA_ARGS__) 2176#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_REQUIRE_NOTHROW, __VA_ARGS__) 2177 2178#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS(expr); } while(false) 2179#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS(expr); } while(false) 2180#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS(expr); } while(false) 2181#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_AS(expr, ex); } while(false) 2182#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_AS(expr, ex); } while(false) 2183#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_AS(expr, ex); } while(false) 2184#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH(expr, with); } while(false) 2185#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH(expr, with); } while(false) 2186#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH(expr, with); } while(false) 2187#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex); } while(false) 2188#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex); } while(false) 2189#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex); } while(false) 2190#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_NOTHROW(expr); } while(false) 2191#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_NOTHROW(expr); } while(false) 2192#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) do { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_NOTHROW(expr); } while(false) 2193// clang-format on 2194 2195#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS 2196 2197#define DOCTEST_BINARY_ASSERT(assert_type, comp, ...) \ 2198 do { \ 2199 doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \ 2200 __LINE__, #__VA_ARGS__); \ 2201 DOCTEST_WRAP_IN_TRY( \ 2202 _DOCTEST_RB.binary_assert<doctest::detail::binaryAssertComparison::comp>( \ 2203 __VA_ARGS__)) \ 2204 DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ 2205 } while(false) 2206 2207#define DOCTEST_UNARY_ASSERT(assert_type, ...) \ 2208 do { \ 2209 doctest::detail::ResultBuilder _DOCTEST_RB(doctest::assertType::assert_type, __FILE__, \ 2210 __LINE__, #__VA_ARGS__); \ 2211 DOCTEST_WRAP_IN_TRY(_DOCTEST_RB.unary_assert(__VA_ARGS__)) \ 2212 DOCTEST_ASSERT_LOG_AND_REACT(_DOCTEST_RB); \ 2213 } while(false) 2214 2215#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS 2216 2217#define DOCTEST_BINARY_ASSERT(assert_type, comparison, ...) \ 2218 doctest::detail::binary_assert<doctest::detail::binaryAssertComparison::comparison>( \ 2219 doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__, __VA_ARGS__) 2220 2221#define DOCTEST_UNARY_ASSERT(assert_type, ...) \ 2222 doctest::detail::unary_assert(doctest::assertType::assert_type, __FILE__, __LINE__, \ 2223 #__VA_ARGS__, __VA_ARGS__) 2224 2225#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS 2226 2227#define DOCTEST_WARN_EQ(...) DOCTEST_BINARY_ASSERT(DT_WARN_EQ, eq, __VA_ARGS__) 2228#define DOCTEST_CHECK_EQ(...) DOCTEST_BINARY_ASSERT(DT_CHECK_EQ, eq, __VA_ARGS__) 2229#define DOCTEST_REQUIRE_EQ(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_EQ, eq, __VA_ARGS__) 2230#define DOCTEST_WARN_NE(...) DOCTEST_BINARY_ASSERT(DT_WARN_NE, ne, __VA_ARGS__) 2231#define DOCTEST_CHECK_NE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_NE, ne, __VA_ARGS__) 2232#define DOCTEST_REQUIRE_NE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_NE, ne, __VA_ARGS__) 2233#define DOCTEST_WARN_GT(...) DOCTEST_BINARY_ASSERT(DT_WARN_GT, gt, __VA_ARGS__) 2234#define DOCTEST_CHECK_GT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GT, gt, __VA_ARGS__) 2235#define DOCTEST_REQUIRE_GT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GT, gt, __VA_ARGS__) 2236#define DOCTEST_WARN_LT(...) DOCTEST_BINARY_ASSERT(DT_WARN_LT, lt, __VA_ARGS__) 2237#define DOCTEST_CHECK_LT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LT, lt, __VA_ARGS__) 2238#define DOCTEST_REQUIRE_LT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LT, lt, __VA_ARGS__) 2239#define DOCTEST_WARN_GE(...) DOCTEST_BINARY_ASSERT(DT_WARN_GE, ge, __VA_ARGS__) 2240#define DOCTEST_CHECK_GE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GE, ge, __VA_ARGS__) 2241#define DOCTEST_REQUIRE_GE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GE, ge, __VA_ARGS__) 2242#define DOCTEST_WARN_LE(...) DOCTEST_BINARY_ASSERT(DT_WARN_LE, le, __VA_ARGS__) 2243#define DOCTEST_CHECK_LE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LE, le, __VA_ARGS__) 2244#define DOCTEST_REQUIRE_LE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LE, le, __VA_ARGS__) 2245 2246#define DOCTEST_WARN_UNARY(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY, __VA_ARGS__) 2247#define DOCTEST_CHECK_UNARY(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY, __VA_ARGS__) 2248#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY, __VA_ARGS__) 2249#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY_FALSE, __VA_ARGS__) 2250#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY_FALSE, __VA_ARGS__) 2251#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY_FALSE, __VA_ARGS__) 2252 2253#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS 2254 2255#undef DOCTEST_WARN_THROWS 2256#undef DOCTEST_CHECK_THROWS 2257#undef DOCTEST_REQUIRE_THROWS 2258#undef DOCTEST_WARN_THROWS_AS 2259#undef DOCTEST_CHECK_THROWS_AS 2260#undef DOCTEST_REQUIRE_THROWS_AS 2261#undef DOCTEST_WARN_THROWS_WITH 2262#undef DOCTEST_CHECK_THROWS_WITH 2263#undef DOCTEST_REQUIRE_THROWS_WITH 2264#undef DOCTEST_WARN_THROWS_WITH_AS 2265#undef DOCTEST_CHECK_THROWS_WITH_AS 2266#undef DOCTEST_REQUIRE_THROWS_WITH_AS 2267#undef DOCTEST_WARN_NOTHROW 2268#undef DOCTEST_CHECK_NOTHROW 2269#undef DOCTEST_REQUIRE_NOTHROW 2270 2271#undef DOCTEST_WARN_THROWS_MESSAGE 2272#undef DOCTEST_CHECK_THROWS_MESSAGE 2273#undef DOCTEST_REQUIRE_THROWS_MESSAGE 2274#undef DOCTEST_WARN_THROWS_AS_MESSAGE 2275#undef DOCTEST_CHECK_THROWS_AS_MESSAGE 2276#undef DOCTEST_REQUIRE_THROWS_AS_MESSAGE 2277#undef DOCTEST_WARN_THROWS_WITH_MESSAGE 2278#undef DOCTEST_CHECK_THROWS_WITH_MESSAGE 2279#undef DOCTEST_REQUIRE_THROWS_WITH_MESSAGE 2280#undef DOCTEST_WARN_THROWS_WITH_AS_MESSAGE 2281#undef DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE 2282#undef DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE 2283#undef DOCTEST_WARN_NOTHROW_MESSAGE 2284#undef DOCTEST_CHECK_NOTHROW_MESSAGE 2285#undef DOCTEST_REQUIRE_NOTHROW_MESSAGE 2286 2287#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS 2288 2289#define DOCTEST_WARN_THROWS(...) (static_cast<void>(0)) 2290#define DOCTEST_CHECK_THROWS(...) (static_cast<void>(0)) 2291#define DOCTEST_REQUIRE_THROWS(...) (static_cast<void>(0)) 2292#define DOCTEST_WARN_THROWS_AS(expr, ...) (static_cast<void>(0)) 2293#define DOCTEST_CHECK_THROWS_AS(expr, ...) (static_cast<void>(0)) 2294#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) (static_cast<void>(0)) 2295#define DOCTEST_WARN_THROWS_WITH(expr, ...) (static_cast<void>(0)) 2296#define DOCTEST_CHECK_THROWS_WITH(expr, ...) (static_cast<void>(0)) 2297#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) (static_cast<void>(0)) 2298#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) (static_cast<void>(0)) 2299#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) (static_cast<void>(0)) 2300#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) (static_cast<void>(0)) 2301#define DOCTEST_WARN_NOTHROW(...) (static_cast<void>(0)) 2302#define DOCTEST_CHECK_NOTHROW(...) (static_cast<void>(0)) 2303#define DOCTEST_REQUIRE_NOTHROW(...) (static_cast<void>(0)) 2304 2305#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) (static_cast<void>(0)) 2306#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) (static_cast<void>(0)) 2307#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) (static_cast<void>(0)) 2308#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) (static_cast<void>(0)) 2309#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) (static_cast<void>(0)) 2310#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) (static_cast<void>(0)) 2311#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) (static_cast<void>(0)) 2312#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) (static_cast<void>(0)) 2313#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) (static_cast<void>(0)) 2314#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) (static_cast<void>(0)) 2315#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) (static_cast<void>(0)) 2316#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) (static_cast<void>(0)) 2317#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) (static_cast<void>(0)) 2318#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) (static_cast<void>(0)) 2319#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) (static_cast<void>(0)) 2320 2321#else // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS 2322 2323#undef DOCTEST_REQUIRE 2324#undef DOCTEST_REQUIRE_FALSE 2325#undef DOCTEST_REQUIRE_MESSAGE 2326#undef DOCTEST_REQUIRE_FALSE_MESSAGE 2327#undef DOCTEST_REQUIRE_EQ 2328#undef DOCTEST_REQUIRE_NE 2329#undef DOCTEST_REQUIRE_GT 2330#undef DOCTEST_REQUIRE_LT 2331#undef DOCTEST_REQUIRE_GE 2332#undef DOCTEST_REQUIRE_LE 2333#undef DOCTEST_REQUIRE_UNARY 2334#undef DOCTEST_REQUIRE_UNARY_FALSE 2335 2336#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS 2337 2338#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 2339 2340// ================================================================================================= 2341// == WHAT FOLLOWS IS VERSIONS OF THE MACROS THAT DO NOT DO ANY REGISTERING! == 2342// == THIS CAN BE ENABLED BY DEFINING DOCTEST_CONFIG_DISABLE GLOBALLY! == 2343// ================================================================================================= 2344#else // DOCTEST_CONFIG_DISABLE 2345 2346#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, name) \ 2347 namespace { \ 2348 template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \ 2349 struct der : public base \ 2350 { void f(); }; \ 2351 } \ 2352 template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \ 2353 inline void der<DOCTEST_UNUSED_TEMPLATE_TYPE>::f() 2354 2355#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, name) \ 2356 template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \ 2357 static inline void f() 2358 2359// for registering tests 2360#define DOCTEST_TEST_CASE(name) \ 2361 DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name) 2362 2363// for registering tests in classes 2364#define DOCTEST_TEST_CASE_CLASS(name) \ 2365 DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name) 2366 2367// for registering tests with a fixture 2368#define DOCTEST_TEST_CASE_FIXTURE(x, name) \ 2369 DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(_DOCTEST_ANON_CLASS_), x, \ 2370 DOCTEST_ANONYMOUS(_DOCTEST_ANON_FUNC_), name) 2371 2372// for converting types to strings without the <typeinfo> header and demangling 2373#define DOCTEST_TYPE_TO_STRING(...) typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2374#define DOCTEST_TYPE_TO_STRING_IMPL(...) 2375 2376// for typed tests 2377#define DOCTEST_TEST_CASE_TEMPLATE(name, type, ...) \ 2378 template <typename type> \ 2379 inline void DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)() 2380 2381#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, type, id) \ 2382 template <typename type> \ 2383 inline void DOCTEST_ANONYMOUS(_DOCTEST_ANON_TMP_)() 2384 2385#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...) \ 2386 typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2387 2388#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...) \ 2389 typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2390 2391// for subcases 2392#define DOCTEST_SUBCASE(name) 2393 2394// for a testsuite block 2395#define DOCTEST_TEST_SUITE(name) namespace 2396 2397// for starting a testsuite block 2398#define DOCTEST_TEST_SUITE_BEGIN(name) typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2399 2400// for ending a testsuite block 2401#define DOCTEST_TEST_SUITE_END typedef int DOCTEST_ANONYMOUS(_DOCTEST_ANON_FOR_SEMICOLON_) 2402 2403#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature) \ 2404 template <typename DOCTEST_UNUSED_TEMPLATE_TYPE> \ 2405 static inline doctest::String DOCTEST_ANONYMOUS(_DOCTEST_ANON_TRANSLATOR_)(signature) 2406 2407#define DOCTEST_REGISTER_REPORTER(name, priority, reporter) 2408#define DOCTEST_REGISTER_LISTENER(name, priority, reporter) 2409 2410#define DOCTEST_INFO(...) (static_cast<void>(0)) 2411#define DOCTEST_CAPTURE(x) (static_cast<void>(0)) 2412#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) (static_cast<void>(0)) 2413#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) (static_cast<void>(0)) 2414#define DOCTEST_ADD_FAIL_AT(file, line, ...) (static_cast<void>(0)) 2415#define DOCTEST_MESSAGE(...) (static_cast<void>(0)) 2416#define DOCTEST_FAIL_CHECK(...) (static_cast<void>(0)) 2417#define DOCTEST_FAIL(...) (static_cast<void>(0)) 2418 2419#define DOCTEST_WARN(...) (static_cast<void>(0)) 2420#define DOCTEST_CHECK(...) (static_cast<void>(0)) 2421#define DOCTEST_REQUIRE(...) (static_cast<void>(0)) 2422#define DOCTEST_WARN_FALSE(...) (static_cast<void>(0)) 2423#define DOCTEST_CHECK_FALSE(...) (static_cast<void>(0)) 2424#define DOCTEST_REQUIRE_FALSE(...) (static_cast<void>(0)) 2425 2426#define DOCTEST_WARN_MESSAGE(cond, ...) (static_cast<void>(0)) 2427#define DOCTEST_CHECK_MESSAGE(cond, ...) (static_cast<void>(0)) 2428#define DOCTEST_REQUIRE_MESSAGE(cond, ...) (static_cast<void>(0)) 2429#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) (static_cast<void>(0)) 2430#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) (static_cast<void>(0)) 2431#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) (static_cast<void>(0)) 2432 2433#define DOCTEST_WARN_THROWS(...) (static_cast<void>(0)) 2434#define DOCTEST_CHECK_THROWS(...) (static_cast<void>(0)) 2435#define DOCTEST_REQUIRE_THROWS(...) (static_cast<void>(0)) 2436#define DOCTEST_WARN_THROWS_AS(expr, ...) (static_cast<void>(0)) 2437#define DOCTEST_CHECK_THROWS_AS(expr, ...) (static_cast<void>(0)) 2438#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) (static_cast<void>(0)) 2439#define DOCTEST_WARN_THROWS_WITH(expr, ...) (static_cast<void>(0)) 2440#define DOCTEST_CHECK_THROWS_WITH(expr, ...) (static_cast<void>(0)) 2441#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) (static_cast<void>(0)) 2442#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) (static_cast<void>(0)) 2443#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) (static_cast<void>(0)) 2444#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) (static_cast<void>(0)) 2445#define DOCTEST_WARN_NOTHROW(...) (static_cast<void>(0)) 2446#define DOCTEST_CHECK_NOTHROW(...) (static_cast<void>(0)) 2447#define DOCTEST_REQUIRE_NOTHROW(...) (static_cast<void>(0)) 2448 2449#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) (static_cast<void>(0)) 2450#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) (static_cast<void>(0)) 2451#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) (static_cast<void>(0)) 2452#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) (static_cast<void>(0)) 2453#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) (static_cast<void>(0)) 2454#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) (static_cast<void>(0)) 2455#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) (static_cast<void>(0)) 2456#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) (static_cast<void>(0)) 2457#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) (static_cast<void>(0)) 2458#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) (static_cast<void>(0)) 2459#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) (static_cast<void>(0)) 2460#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) (static_cast<void>(0)) 2461#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) (static_cast<void>(0)) 2462#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) (static_cast<void>(0)) 2463#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) (static_cast<void>(0)) 2464 2465#define DOCTEST_WARN_EQ(...) (static_cast<void>(0)) 2466#define DOCTEST_CHECK_EQ(...) (static_cast<void>(0)) 2467#define DOCTEST_REQUIRE_EQ(...) (static_cast<void>(0)) 2468#define DOCTEST_WARN_NE(...) (static_cast<void>(0)) 2469#define DOCTEST_CHECK_NE(...) (static_cast<void>(0)) 2470#define DOCTEST_REQUIRE_NE(...) (static_cast<void>(0)) 2471#define DOCTEST_WARN_GT(...) (static_cast<void>(0)) 2472#define DOCTEST_CHECK_GT(...) (static_cast<void>(0)) 2473#define DOCTEST_REQUIRE_GT(...) (static_cast<void>(0)) 2474#define DOCTEST_WARN_LT(...) (static_cast<void>(0)) 2475#define DOCTEST_CHECK_LT(...) (static_cast<void>(0)) 2476#define DOCTEST_REQUIRE_LT(...) (static_cast<void>(0)) 2477#define DOCTEST_WARN_GE(...) (static_cast<void>(0)) 2478#define DOCTEST_CHECK_GE(...) (static_cast<void>(0)) 2479#define DOCTEST_REQUIRE_GE(...) (static_cast<void>(0)) 2480#define DOCTEST_WARN_LE(...) (static_cast<void>(0)) 2481#define DOCTEST_CHECK_LE(...) (static_cast<void>(0)) 2482#define DOCTEST_REQUIRE_LE(...) (static_cast<void>(0)) 2483 2484#define DOCTEST_WARN_UNARY(...) (static_cast<void>(0)) 2485#define DOCTEST_CHECK_UNARY(...) (static_cast<void>(0)) 2486#define DOCTEST_REQUIRE_UNARY(...) (static_cast<void>(0)) 2487#define DOCTEST_WARN_UNARY_FALSE(...) (static_cast<void>(0)) 2488#define DOCTEST_CHECK_UNARY_FALSE(...) (static_cast<void>(0)) 2489#define DOCTEST_REQUIRE_UNARY_FALSE(...) (static_cast<void>(0)) 2490 2491#endif // DOCTEST_CONFIG_DISABLE 2492 2493// clang-format off 2494// KEPT FOR BACKWARDS COMPATIBILITY - FORWARDING TO THE RIGHT MACROS 2495#define DOCTEST_FAST_WARN_EQ DOCTEST_WARN_EQ 2496#define DOCTEST_FAST_CHECK_EQ DOCTEST_CHECK_EQ 2497#define DOCTEST_FAST_REQUIRE_EQ DOCTEST_REQUIRE_EQ 2498#define DOCTEST_FAST_WARN_NE DOCTEST_WARN_NE 2499#define DOCTEST_FAST_CHECK_NE DOCTEST_CHECK_NE 2500#define DOCTEST_FAST_REQUIRE_NE DOCTEST_REQUIRE_NE 2501#define DOCTEST_FAST_WARN_GT DOCTEST_WARN_GT 2502#define DOCTEST_FAST_CHECK_GT DOCTEST_CHECK_GT 2503#define DOCTEST_FAST_REQUIRE_GT DOCTEST_REQUIRE_GT 2504#define DOCTEST_FAST_WARN_LT DOCTEST_WARN_LT 2505#define DOCTEST_FAST_CHECK_LT DOCTEST_CHECK_LT 2506#define DOCTEST_FAST_REQUIRE_LT DOCTEST_REQUIRE_LT 2507#define DOCTEST_FAST_WARN_GE DOCTEST_WARN_GE 2508#define DOCTEST_FAST_CHECK_GE DOCTEST_CHECK_GE 2509#define DOCTEST_FAST_REQUIRE_GE DOCTEST_REQUIRE_GE 2510#define DOCTEST_FAST_WARN_LE DOCTEST_WARN_LE 2511#define DOCTEST_FAST_CHECK_LE DOCTEST_CHECK_LE 2512#define DOCTEST_FAST_REQUIRE_LE DOCTEST_REQUIRE_LE 2513 2514#define DOCTEST_FAST_WARN_UNARY DOCTEST_WARN_UNARY 2515#define DOCTEST_FAST_CHECK_UNARY DOCTEST_CHECK_UNARY 2516#define DOCTEST_FAST_REQUIRE_UNARY DOCTEST_REQUIRE_UNARY 2517#define DOCTEST_FAST_WARN_UNARY_FALSE DOCTEST_WARN_UNARY_FALSE 2518#define DOCTEST_FAST_CHECK_UNARY_FALSE DOCTEST_CHECK_UNARY_FALSE 2519#define DOCTEST_FAST_REQUIRE_UNARY_FALSE DOCTEST_REQUIRE_UNARY_FALSE 2520 2521#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id,__VA_ARGS__) 2522// clang-format on 2523 2524// BDD style macros 2525// clang-format off 2526#define DOCTEST_SCENARIO(name) DOCTEST_TEST_CASE(" Scenario: " name) 2527#define DOCTEST_SCENARIO_CLASS(name) DOCTEST_TEST_CASE_CLASS(" Scenario: " name) 2528#define DOCTEST_SCENARIO_TEMPLATE(name, T, ...) DOCTEST_TEST_CASE_TEMPLATE(" Scenario: " name, T, __VA_ARGS__) 2529#define DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE(" Scenario: " name, T, id) 2530 2531#define DOCTEST_GIVEN(name) DOCTEST_SUBCASE(" Given: " name) 2532#define DOCTEST_WHEN(name) DOCTEST_SUBCASE(" When: " name) 2533#define DOCTEST_AND_WHEN(name) DOCTEST_SUBCASE("And when: " name) 2534#define DOCTEST_THEN(name) DOCTEST_SUBCASE(" Then: " name) 2535#define DOCTEST_AND_THEN(name) DOCTEST_SUBCASE(" And: " name) 2536// clang-format on 2537 2538// == SHORT VERSIONS OF THE MACROS 2539#if !defined(DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES) 2540 2541#define TEST_CASE(name) DOCTEST_TEST_CASE(name) 2542#define TEST_CASE_CLASS(name) DOCTEST_TEST_CASE_CLASS(name) 2543#define TEST_CASE_FIXTURE(x, name) DOCTEST_TEST_CASE_FIXTURE(x, name) 2544#define TYPE_TO_STRING(...) DOCTEST_TYPE_TO_STRING(__VA_ARGS__) 2545#define TEST_CASE_TEMPLATE(name, T, ...) DOCTEST_TEST_CASE_TEMPLATE(name, T, __VA_ARGS__) 2546#define TEST_CASE_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, T, id) 2547#define TEST_CASE_TEMPLATE_INVOKE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, __VA_ARGS__) 2548#define TEST_CASE_TEMPLATE_APPLY(id, ...) DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, __VA_ARGS__) 2549#define SUBCASE(name) DOCTEST_SUBCASE(name) 2550#define TEST_SUITE(decorators) DOCTEST_TEST_SUITE(decorators) 2551#define TEST_SUITE_BEGIN(name) DOCTEST_TEST_SUITE_BEGIN(name) 2552#define TEST_SUITE_END DOCTEST_TEST_SUITE_END 2553#define REGISTER_EXCEPTION_TRANSLATOR(signature) DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature) 2554#define REGISTER_REPORTER(name, priority, reporter) DOCTEST_REGISTER_REPORTER(name, priority, reporter) 2555#define REGISTER_LISTENER(name, priority, reporter) DOCTEST_REGISTER_LISTENER(name, priority, reporter) 2556#define INFO(...) DOCTEST_INFO(__VA_ARGS__) 2557#define CAPTURE(x) DOCTEST_CAPTURE(x) 2558#define ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_MESSAGE_AT(file, line, __VA_ARGS__) 2559#define ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_FAIL_CHECK_AT(file, line, __VA_ARGS__) 2560#define ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_FAIL_AT(file, line, __VA_ARGS__) 2561#define MESSAGE(...) DOCTEST_MESSAGE(__VA_ARGS__) 2562#define FAIL_CHECK(...) DOCTEST_FAIL_CHECK(__VA_ARGS__) 2563#define FAIL(...) DOCTEST_FAIL(__VA_ARGS__) 2564#define TO_LVALUE(...) DOCTEST_TO_LVALUE(__VA_ARGS__) 2565 2566#define WARN(...) DOCTEST_WARN(__VA_ARGS__) 2567#define WARN_FALSE(...) DOCTEST_WARN_FALSE(__VA_ARGS__) 2568#define WARN_THROWS(...) DOCTEST_WARN_THROWS(__VA_ARGS__) 2569#define WARN_THROWS_AS(expr, ...) DOCTEST_WARN_THROWS_AS(expr, __VA_ARGS__) 2570#define WARN_THROWS_WITH(expr, ...) DOCTEST_WARN_THROWS_WITH(expr, __VA_ARGS__) 2571#define WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_WARN_THROWS_WITH_AS(expr, with, __VA_ARGS__) 2572#define WARN_NOTHROW(...) DOCTEST_WARN_NOTHROW(__VA_ARGS__) 2573#define CHECK(...) DOCTEST_CHECK(__VA_ARGS__) 2574#define CHECK_FALSE(...) DOCTEST_CHECK_FALSE(__VA_ARGS__) 2575#define CHECK_THROWS(...) DOCTEST_CHECK_THROWS(__VA_ARGS__) 2576#define CHECK_THROWS_AS(expr, ...) DOCTEST_CHECK_THROWS_AS(expr, __VA_ARGS__) 2577#define CHECK_THROWS_WITH(expr, ...) DOCTEST_CHECK_THROWS_WITH(expr, __VA_ARGS__) 2578#define CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_AS(expr, with, __VA_ARGS__) 2579#define CHECK_NOTHROW(...) DOCTEST_CHECK_NOTHROW(__VA_ARGS__) 2580#define REQUIRE(...) DOCTEST_REQUIRE(__VA_ARGS__) 2581#define REQUIRE_FALSE(...) DOCTEST_REQUIRE_FALSE(__VA_ARGS__) 2582#define REQUIRE_THROWS(...) DOCTEST_REQUIRE_THROWS(__VA_ARGS__) 2583#define REQUIRE_THROWS_AS(expr, ...) DOCTEST_REQUIRE_THROWS_AS(expr, __VA_ARGS__) 2584#define REQUIRE_THROWS_WITH(expr, ...) DOCTEST_REQUIRE_THROWS_WITH(expr, __VA_ARGS__) 2585#define REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, __VA_ARGS__) 2586#define REQUIRE_NOTHROW(...) DOCTEST_REQUIRE_NOTHROW(__VA_ARGS__) 2587 2588#define WARN_MESSAGE(cond, ...) DOCTEST_WARN_MESSAGE(cond, __VA_ARGS__) 2589#define WARN_FALSE_MESSAGE(cond, ...) DOCTEST_WARN_FALSE_MESSAGE(cond, __VA_ARGS__) 2590#define WARN_THROWS_MESSAGE(expr, ...) DOCTEST_WARN_THROWS_MESSAGE(expr, __VA_ARGS__) 2591#define WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__) 2592#define WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__) 2593#define WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__) 2594#define WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_WARN_NOTHROW_MESSAGE(expr, __VA_ARGS__) 2595#define CHECK_MESSAGE(cond, ...) DOCTEST_CHECK_MESSAGE(cond, __VA_ARGS__) 2596#define CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_CHECK_FALSE_MESSAGE(cond, __VA_ARGS__) 2597#define CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_CHECK_THROWS_MESSAGE(expr, __VA_ARGS__) 2598#define CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__) 2599#define CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__) 2600#define CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__) 2601#define CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_CHECK_NOTHROW_MESSAGE(expr, __VA_ARGS__) 2602#define REQUIRE_MESSAGE(cond, ...) DOCTEST_REQUIRE_MESSAGE(cond, __VA_ARGS__) 2603#define REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_REQUIRE_FALSE_MESSAGE(cond, __VA_ARGS__) 2604#define REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_REQUIRE_THROWS_MESSAGE(expr, __VA_ARGS__) 2605#define REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__) 2606#define REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__) 2607#define REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__) 2608#define REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, __VA_ARGS__) 2609 2610#define SCENARIO(name) DOCTEST_SCENARIO(name) 2611#define SCENARIO_CLASS(name) DOCTEST_SCENARIO_CLASS(name) 2612#define SCENARIO_TEMPLATE(name, T, ...) DOCTEST_SCENARIO_TEMPLATE(name, T, __VA_ARGS__) 2613#define SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id) 2614#define GIVEN(name) DOCTEST_GIVEN(name) 2615#define WHEN(name) DOCTEST_WHEN(name) 2616#define AND_WHEN(name) DOCTEST_AND_WHEN(name) 2617#define THEN(name) DOCTEST_THEN(name) 2618#define AND_THEN(name) DOCTEST_AND_THEN(name) 2619 2620#define WARN_EQ(...) DOCTEST_WARN_EQ(__VA_ARGS__) 2621#define CHECK_EQ(...) DOCTEST_CHECK_EQ(__VA_ARGS__) 2622#define REQUIRE_EQ(...) DOCTEST_REQUIRE_EQ(__VA_ARGS__) 2623#define WARN_NE(...) DOCTEST_WARN_NE(__VA_ARGS__) 2624#define CHECK_NE(...) DOCTEST_CHECK_NE(__VA_ARGS__) 2625#define REQUIRE_NE(...) DOCTEST_REQUIRE_NE(__VA_ARGS__) 2626#define WARN_GT(...) DOCTEST_WARN_GT(__VA_ARGS__) 2627#define CHECK_GT(...) DOCTEST_CHECK_GT(__VA_ARGS__) 2628#define REQUIRE_GT(...) DOCTEST_REQUIRE_GT(__VA_ARGS__) 2629#define WARN_LT(...) DOCTEST_WARN_LT(__VA_ARGS__) 2630#define CHECK_LT(...) DOCTEST_CHECK_LT(__VA_ARGS__) 2631#define REQUIRE_LT(...) DOCTEST_REQUIRE_LT(__VA_ARGS__) 2632#define WARN_GE(...) DOCTEST_WARN_GE(__VA_ARGS__) 2633#define CHECK_GE(...) DOCTEST_CHECK_GE(__VA_ARGS__) 2634#define REQUIRE_GE(...) DOCTEST_REQUIRE_GE(__VA_ARGS__) 2635#define WARN_LE(...) DOCTEST_WARN_LE(__VA_ARGS__) 2636#define CHECK_LE(...) DOCTEST_CHECK_LE(__VA_ARGS__) 2637#define REQUIRE_LE(...) DOCTEST_REQUIRE_LE(__VA_ARGS__) 2638#define WARN_UNARY(...) DOCTEST_WARN_UNARY(__VA_ARGS__) 2639#define CHECK_UNARY(...) DOCTEST_CHECK_UNARY(__VA_ARGS__) 2640#define REQUIRE_UNARY(...) DOCTEST_REQUIRE_UNARY(__VA_ARGS__) 2641#define WARN_UNARY_FALSE(...) DOCTEST_WARN_UNARY_FALSE(__VA_ARGS__) 2642#define CHECK_UNARY_FALSE(...) DOCTEST_CHECK_UNARY_FALSE(__VA_ARGS__) 2643#define REQUIRE_UNARY_FALSE(...) DOCTEST_REQUIRE_UNARY_FALSE(__VA_ARGS__) 2644 2645// KEPT FOR BACKWARDS COMPATIBILITY 2646#define FAST_WARN_EQ(...) DOCTEST_FAST_WARN_EQ(__VA_ARGS__) 2647#define FAST_CHECK_EQ(...) DOCTEST_FAST_CHECK_EQ(__VA_ARGS__) 2648#define FAST_REQUIRE_EQ(...) DOCTEST_FAST_REQUIRE_EQ(__VA_ARGS__) 2649#define FAST_WARN_NE(...) DOCTEST_FAST_WARN_NE(__VA_ARGS__) 2650#define FAST_CHECK_NE(...) DOCTEST_FAST_CHECK_NE(__VA_ARGS__) 2651#define FAST_REQUIRE_NE(...) DOCTEST_FAST_REQUIRE_NE(__VA_ARGS__) 2652#define FAST_WARN_GT(...) DOCTEST_FAST_WARN_GT(__VA_ARGS__) 2653#define FAST_CHECK_GT(...) DOCTEST_FAST_CHECK_GT(__VA_ARGS__) 2654#define FAST_REQUIRE_GT(...) DOCTEST_FAST_REQUIRE_GT(__VA_ARGS__) 2655#define FAST_WARN_LT(...) DOCTEST_FAST_WARN_LT(__VA_ARGS__) 2656#define FAST_CHECK_LT(...) DOCTEST_FAST_CHECK_LT(__VA_ARGS__) 2657#define FAST_REQUIRE_LT(...) DOCTEST_FAST_REQUIRE_LT(__VA_ARGS__) 2658#define FAST_WARN_GE(...) DOCTEST_FAST_WARN_GE(__VA_ARGS__) 2659#define FAST_CHECK_GE(...) DOCTEST_FAST_CHECK_GE(__VA_ARGS__) 2660#define FAST_REQUIRE_GE(...) DOCTEST_FAST_REQUIRE_GE(__VA_ARGS__) 2661#define FAST_WARN_LE(...) DOCTEST_FAST_WARN_LE(__VA_ARGS__) 2662#define FAST_CHECK_LE(...) DOCTEST_FAST_CHECK_LE(__VA_ARGS__) 2663#define FAST_REQUIRE_LE(...) DOCTEST_FAST_REQUIRE_LE(__VA_ARGS__) 2664 2665#define FAST_WARN_UNARY(...) DOCTEST_FAST_WARN_UNARY(__VA_ARGS__) 2666#define FAST_CHECK_UNARY(...) DOCTEST_FAST_CHECK_UNARY(__VA_ARGS__) 2667#define FAST_REQUIRE_UNARY(...) DOCTEST_FAST_REQUIRE_UNARY(__VA_ARGS__) 2668#define FAST_WARN_UNARY_FALSE(...) DOCTEST_FAST_WARN_UNARY_FALSE(__VA_ARGS__) 2669#define FAST_CHECK_UNARY_FALSE(...) DOCTEST_FAST_CHECK_UNARY_FALSE(__VA_ARGS__) 2670#define FAST_REQUIRE_UNARY_FALSE(...) DOCTEST_FAST_REQUIRE_UNARY_FALSE(__VA_ARGS__) 2671 2672#define TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, __VA_ARGS__) 2673 2674#endif // DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES 2675 2676#if !defined(DOCTEST_CONFIG_DISABLE) 2677 2678// this is here to clear the 'current test suite' for the current translation unit - at the top 2679DOCTEST_TEST_SUITE_END(); 2680 2681// add stringification for primitive/fundamental types 2682namespace doctest { namespace detail { 2683 DOCTEST_TYPE_TO_STRING_IMPL(bool) 2684 DOCTEST_TYPE_TO_STRING_IMPL(float) 2685 DOCTEST_TYPE_TO_STRING_IMPL(double) 2686 DOCTEST_TYPE_TO_STRING_IMPL(long double) 2687 DOCTEST_TYPE_TO_STRING_IMPL(char) 2688 DOCTEST_TYPE_TO_STRING_IMPL(signed char) 2689 DOCTEST_TYPE_TO_STRING_IMPL(unsigned char) 2690#if !DOCTEST_MSVC || defined(_NATIVE_WCHAR_T_DEFINED) 2691 DOCTEST_TYPE_TO_STRING_IMPL(wchar_t) 2692#endif // not MSVC or wchar_t support enabled 2693 DOCTEST_TYPE_TO_STRING_IMPL(short int) 2694 DOCTEST_TYPE_TO_STRING_IMPL(unsigned short int) 2695 DOCTEST_TYPE_TO_STRING_IMPL(int) 2696 DOCTEST_TYPE_TO_STRING_IMPL(unsigned int) 2697 DOCTEST_TYPE_TO_STRING_IMPL(long int) 2698 DOCTEST_TYPE_TO_STRING_IMPL(unsigned long int) 2699 DOCTEST_TYPE_TO_STRING_IMPL(long long int) 2700 DOCTEST_TYPE_TO_STRING_IMPL(unsigned long long int) 2701}} // namespace doctest::detail 2702 2703#endif // DOCTEST_CONFIG_DISABLE 2704 2705DOCTEST_CLANG_SUPPRESS_WARNING_POP 2706DOCTEST_MSVC_SUPPRESS_WARNING_POP 2707DOCTEST_GCC_SUPPRESS_WARNING_POP 2708 2709#endif // DOCTEST_LIBRARY_INCLUDED 2710 2711#ifndef DOCTEST_SINGLE_HEADER 2712#define DOCTEST_SINGLE_HEADER 2713#endif // DOCTEST_SINGLE_HEADER 2714 2715#if defined(DOCTEST_CONFIG_IMPLEMENT) || !defined(DOCTEST_SINGLE_HEADER) 2716 2717#ifndef DOCTEST_SINGLE_HEADER 2718#include "doctest_fwd.h" 2719#endif // DOCTEST_SINGLE_HEADER 2720 2721DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-macros") 2722 2723#ifndef DOCTEST_LIBRARY_IMPLEMENTATION 2724#define DOCTEST_LIBRARY_IMPLEMENTATION 2725 2726DOCTEST_CLANG_SUPPRESS_WARNING_POP 2727 2728DOCTEST_CLANG_SUPPRESS_WARNING_PUSH 2729DOCTEST_CLANG_SUPPRESS_WARNING("-Wunknown-pragmas") 2730DOCTEST_CLANG_SUPPRESS_WARNING("-Wpadded") 2731DOCTEST_CLANG_SUPPRESS_WARNING("-Wweak-vtables") 2732DOCTEST_CLANG_SUPPRESS_WARNING("-Wglobal-constructors") 2733DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors") 2734DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes") 2735DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion") 2736DOCTEST_CLANG_SUPPRESS_WARNING("-Wshorten-64-to-32") 2737DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-variable-declarations") 2738DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch") 2739DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch-enum") 2740DOCTEST_CLANG_SUPPRESS_WARNING("-Wcovered-switch-default") 2741DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-noreturn") 2742DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-local-typedef") 2743DOCTEST_CLANG_SUPPRESS_WARNING("-Wdisabled-macro-expansion") 2744DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-braces") 2745DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-field-initializers") 2746DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat") 2747DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic") 2748DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-member-function") 2749DOCTEST_CLANG_SUPPRESS_WARNING("-Wnonportable-system-include-path") 2750 2751DOCTEST_GCC_SUPPRESS_WARNING_PUSH 2752DOCTEST_GCC_SUPPRESS_WARNING("-Wunknown-pragmas") 2753DOCTEST_GCC_SUPPRESS_WARNING("-Wpragmas") 2754DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion") 2755DOCTEST_GCC_SUPPRESS_WARNING("-Weffc++") 2756DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion") 2757DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-overflow") 2758DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-aliasing") 2759DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-field-initializers") 2760DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-braces") 2761DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-declarations") 2762DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch") 2763DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-enum") 2764DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-default") 2765DOCTEST_GCC_SUPPRESS_WARNING("-Wunsafe-loop-optimizations") 2766DOCTEST_GCC_SUPPRESS_WARNING("-Wold-style-cast") 2767DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-local-typedefs") 2768DOCTEST_GCC_SUPPRESS_WARNING("-Wuseless-cast") 2769DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-function") 2770DOCTEST_GCC_SUPPRESS_WARNING("-Wmultiple-inheritance") 2771DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept") 2772DOCTEST_GCC_SUPPRESS_WARNING("-Wsuggest-attribute") 2773 2774DOCTEST_MSVC_SUPPRESS_WARNING_PUSH 2775DOCTEST_MSVC_SUPPRESS_WARNING(4616) // invalid compiler warning 2776DOCTEST_MSVC_SUPPRESS_WARNING(4619) // invalid compiler warning 2777DOCTEST_MSVC_SUPPRESS_WARNING(4996) // The compiler encountered a deprecated declaration 2778DOCTEST_MSVC_SUPPRESS_WARNING(4267) // 'var' : conversion from 'x' to 'y', possible loss of data 2779DOCTEST_MSVC_SUPPRESS_WARNING(4706) // assignment within conditional expression 2780DOCTEST_MSVC_SUPPRESS_WARNING(4512) // 'class' : assignment operator could not be generated 2781DOCTEST_MSVC_SUPPRESS_WARNING(4127) // conditional expression is constant 2782DOCTEST_MSVC_SUPPRESS_WARNING(4530) // C++ exception handler used, but unwind semantics not enabled 2783DOCTEST_MSVC_SUPPRESS_WARNING(4577) // 'noexcept' used with no exception handling mode specified 2784DOCTEST_MSVC_SUPPRESS_WARNING(4774) // format string expected in argument is not a string literal 2785DOCTEST_MSVC_SUPPRESS_WARNING(4365) // conversion from 'int' to 'unsigned', signed/unsigned mismatch 2786DOCTEST_MSVC_SUPPRESS_WARNING(4820) // padding in structs 2787DOCTEST_MSVC_SUPPRESS_WARNING(4640) // construction of local static object is not thread-safe 2788DOCTEST_MSVC_SUPPRESS_WARNING(5039) // pointer to potentially throwing function passed to extern C 2789DOCTEST_MSVC_SUPPRESS_WARNING(5045) // Spectre mitigation stuff 2790DOCTEST_MSVC_SUPPRESS_WARNING(4626) // assignment operator was implicitly defined as deleted 2791DOCTEST_MSVC_SUPPRESS_WARNING(5027) // move assignment operator was implicitly defined as deleted 2792DOCTEST_MSVC_SUPPRESS_WARNING(5026) // move constructor was implicitly defined as deleted 2793DOCTEST_MSVC_SUPPRESS_WARNING(4625) // copy constructor was implicitly defined as deleted 2794DOCTEST_MSVC_SUPPRESS_WARNING(4800) // forcing value to bool 'true' or 'false' (performance warning) 2795// static analysis 2796DOCTEST_MSVC_SUPPRESS_WARNING(26439) // This kind of function may not throw. Declare it 'noexcept' 2797DOCTEST_MSVC_SUPPRESS_WARNING(26495) // Always initialize a member variable 2798DOCTEST_MSVC_SUPPRESS_WARNING(26451) // Arithmetic overflow ... 2799DOCTEST_MSVC_SUPPRESS_WARNING(26444) // Avoid unnamed objects with custom construction and dtor... 2800DOCTEST_MSVC_SUPPRESS_WARNING(26812) // Prefer 'enum class' over 'enum' 2801 2802DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN 2803 2804// required includes - will go only in one translation unit! 2805#include <ctime> 2806#include <cmath> 2807#include <climits> 2808// borland (Embarcadero) compiler requires math.h and not cmath - https://github.com/onqtam/doctest/pull/37 2809#ifdef __BORLANDC__ 2810#include <math.h> 2811#endif // __BORLANDC__ 2812#include <new> 2813#include <cstdio> 2814#include <cstdlib> 2815#include <cstring> 2816#include <limits> 2817#include <utility> 2818#include <fstream> 2819#include <sstream> 2820#include <iostream> 2821#include <algorithm> 2822#include <iomanip> 2823#include <vector> 2824#include <atomic> 2825#include <mutex> 2826#include <set> 2827#include <map> 2828#include <exception> 2829#include <stdexcept> 2830#include <csignal> 2831#include <cfloat> 2832#include <cctype> 2833#include <cstdint> 2834 2835#ifdef DOCTEST_PLATFORM_MAC 2836#include <sys/types.h> 2837#include <unistd.h> 2838#include <sys/sysctl.h> 2839#endif // DOCTEST_PLATFORM_MAC 2840 2841#ifdef DOCTEST_PLATFORM_WINDOWS 2842 2843// defines for a leaner windows.h 2844#ifndef WIN32_LEAN_AND_MEAN 2845#define WIN32_LEAN_AND_MEAN 2846#endif // WIN32_LEAN_AND_MEAN 2847#ifndef NOMINMAX 2848#define NOMINMAX 2849#endif // NOMINMAX 2850 2851// not sure what AfxWin.h is for - here I do what Catch does 2852#ifdef __AFXDLL 2853#include <AfxWin.h> 2854#else 2855#include <windows.h> 2856#endif 2857#include <io.h> 2858 2859#else // DOCTEST_PLATFORM_WINDOWS 2860 2861#include <sys/time.h> 2862#include <unistd.h> 2863 2864#endif // DOCTEST_PLATFORM_WINDOWS 2865 2866// this is a fix for https://github.com/onqtam/doctest/issues/348 2867// https://mail.gnome.org/archives/xml/2012-January/msg00000.html 2868#if !defined(HAVE_UNISTD_H) && !defined(STDOUT_FILENO) 2869#define STDOUT_FILENO fileno(stdout) 2870#endif // HAVE_UNISTD_H 2871 2872DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END 2873 2874// counts the number of elements in a C array 2875#define DOCTEST_COUNTOF(x) (sizeof(x) / sizeof(x[0])) 2876 2877#ifdef DOCTEST_CONFIG_DISABLE 2878#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_disabled 2879#else // DOCTEST_CONFIG_DISABLE 2880#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_not_disabled 2881#endif // DOCTEST_CONFIG_DISABLE 2882 2883#ifndef DOCTEST_CONFIG_OPTIONS_PREFIX 2884#define DOCTEST_CONFIG_OPTIONS_PREFIX "dt-" 2885#endif 2886 2887#ifndef DOCTEST_THREAD_LOCAL 2888#define DOCTEST_THREAD_LOCAL thread_local 2889#endif 2890 2891#ifndef DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES 2892#define DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES 32 2893#endif 2894 2895#ifndef DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE 2896#define DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE 64 2897#endif 2898 2899#ifdef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS 2900#define DOCTEST_OPTIONS_PREFIX_DISPLAY DOCTEST_CONFIG_OPTIONS_PREFIX 2901#else 2902#define DOCTEST_OPTIONS_PREFIX_DISPLAY "" 2903#endif 2904 2905#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) 2906#define DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS 2907#endif 2908 2909namespace doctest { 2910 2911bool is_running_in_test = false; 2912 2913namespace { 2914 using namespace detail; 2915 // case insensitive strcmp 2916 int stricmp(const char* a, const char* b) { 2917 for(;; a++, b++) { 2918 const int d = tolower(*a) - tolower(*b); 2919 if(d != 0 || !*a) 2920 return d; 2921 } 2922 } 2923 2924 template <typename T> 2925 String fpToString(T value, int precision) { 2926 std::ostringstream oss; 2927 oss << std::setprecision(precision) << std::fixed << value; 2928 std::string d = oss.str(); 2929 size_t i = d.find_last_not_of('0'); 2930 if(i != std::string::npos && i != d.size() - 1) { 2931 if(d[i] == '.') 2932 i++; 2933 d = d.substr(0, i + 1); 2934 } 2935 return d.c_str(); 2936 } 2937 2938 struct Endianness 2939 { 2940 enum Arch 2941 { 2942 Big, 2943 Little 2944 }; 2945 2946 static Arch which() { 2947 int x = 1; 2948 // casting any data pointer to char* is allowed 2949 auto ptr = reinterpret_cast<char*>(&x); 2950 if(*ptr) 2951 return Little; 2952 return Big; 2953 } 2954 }; 2955} // namespace 2956 2957namespace detail { 2958 void my_memcpy(void* dest, const void* src, unsigned num) { memcpy(dest, src, num); } 2959 2960 String rawMemoryToString(const void* object, unsigned size) { 2961 // Reverse order for little endian architectures 2962 int i = 0, end = static_cast<int>(size), inc = 1; 2963 if(Endianness::which() == Endianness::Little) { 2964 i = end - 1; 2965 end = inc = -1; 2966 } 2967 2968 unsigned const char* bytes = static_cast<unsigned const char*>(object); 2969 std::ostringstream oss; 2970 oss << "0x" << std::setfill('0') << std::hex; 2971 for(; i != end; i += inc) 2972 oss << std::setw(2) << static_cast<unsigned>(bytes[i]); 2973 return oss.str().c_str(); 2974 } 2975 2976 DOCTEST_THREAD_LOCAL std::ostringstream g_oss; // NOLINT(cert-err58-cpp) 2977 2978 std::ostream* getTlsOss() { 2979 g_oss.clear(); // there shouldn't be anything worth clearing in the flags 2980 g_oss.str(""); // the slow way of resetting a string stream 2981 //g_oss.seekp(0); // optimal reset - as seen here: https://stackoverflow.com/a/624291/3162383 2982 return &g_oss; 2983 } 2984 2985 String getTlsOssResult() { 2986 //g_oss << std::ends; // needed - as shown here: https://stackoverflow.com/a/624291/3162383 2987 return g_oss.str().c_str(); 2988 } 2989 2990#ifndef DOCTEST_CONFIG_DISABLE 2991 2992namespace timer_large_integer 2993{ 2994 2995#if defined(DOCTEST_PLATFORM_WINDOWS) 2996 typedef ULONGLONG type; 2997#else // DOCTEST_PLATFORM_WINDOWS 2998 using namespace std; 2999 typedef uint64_t type; 3000#endif // DOCTEST_PLATFORM_WINDOWS 3001} 3002 3003typedef timer_large_integer::type ticks_t; 3004 3005#ifdef DOCTEST_CONFIG_GETCURRENTTICKS 3006 ticks_t getCurrentTicks() { return DOCTEST_CONFIG_GETCURRENTTICKS(); } 3007#elif defined(DOCTEST_PLATFORM_WINDOWS) 3008 ticks_t getCurrentTicks() { 3009 static LARGE_INTEGER hz = {0}, hzo = {0}; 3010 if(!hz.QuadPart) { 3011 QueryPerformanceFrequency(&hz); 3012 QueryPerformanceCounter(&hzo); 3013 } 3014 LARGE_INTEGER t; 3015 QueryPerformanceCounter(&t); 3016 return ((t.QuadPart - hzo.QuadPart) * LONGLONG(1000000)) / hz.QuadPart; 3017 } 3018#else // DOCTEST_PLATFORM_WINDOWS 3019 ticks_t getCurrentTicks() { 3020 timeval t; 3021 gettimeofday(&t, nullptr); 3022 return static_cast<ticks_t>(t.tv_sec) * 1000000 + static_cast<ticks_t>(t.tv_usec); 3023 } 3024#endif // DOCTEST_PLATFORM_WINDOWS 3025 3026 struct Timer 3027 { 3028 void start() { m_ticks = getCurrentTicks(); } 3029 unsigned int getElapsedMicroseconds() const { 3030 return static_cast<unsigned int>(getCurrentTicks() - m_ticks); 3031 } 3032 //unsigned int getElapsedMilliseconds() const { 3033 // return static_cast<unsigned int>(getElapsedMicroseconds() / 1000); 3034 //} 3035 double getElapsedSeconds() const { return static_cast<double>(getCurrentTicks() - m_ticks) / 1000000.0; } 3036 3037 private: 3038 ticks_t m_ticks = 0; 3039 }; 3040 3041#ifdef DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS 3042 template <typename T> 3043 using AtomicOrMultiLaneAtomic = std::atomic<T>; 3044#else // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS 3045 // Provides a multilane implementation of an atomic variable that supports add, sub, load, 3046 // store. Instead of using a single atomic variable, this splits up into multiple ones, 3047 // each sitting on a separate cache line. The goal is to provide a speedup when most 3048 // operations are modifying. It achieves this with two properties: 3049 // 3050 // * Multiple atomics are used, so chance of congestion from the same atomic is reduced. 3051 // * Each atomic sits on a separate cache line, so false sharing is reduced. 3052 // 3053 // The disadvantage is that there is a small overhead due to the use of TLS, and load/store 3054 // is slower because all atomics have to be accessed. 3055 template <typename T> 3056 class MultiLaneAtomic 3057 { 3058 struct CacheLineAlignedAtomic 3059 { 3060 std::atomic<T> atomic{}; 3061 char padding[DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE - sizeof(std::atomic<T>)]; 3062 }; 3063 CacheLineAlignedAtomic m_atomics[DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES]; 3064 3065 static_assert(sizeof(CacheLineAlignedAtomic) == DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE, 3066 "guarantee one atomic takes exactly one cache line"); 3067 3068 public: 3069 T operator++() DOCTEST_NOEXCEPT { return fetch_add(1) + 1; } 3070 3071 T operator++(int) DOCTEST_NOEXCEPT { return fetch_add(1); } 3072 3073 T fetch_add(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT { 3074 return myAtomic().fetch_add(arg, order); 3075 } 3076 3077 T fetch_sub(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT { 3078 return myAtomic().fetch_sub(arg, order); 3079 } 3080 3081 operator T() const DOCTEST_NOEXCEPT { return load(); } 3082 3083 T load(std::memory_order order = std::memory_order_seq_cst) const DOCTEST_NOEXCEPT { 3084 auto result = T(); 3085 for(auto const& c : m_atomics) { 3086 result += c.atomic.load(order); 3087 } 3088 return result; 3089 } 3090 3091 T operator=(T desired) DOCTEST_NOEXCEPT { 3092 store(desired); 3093 return desired; 3094 } 3095 3096 void store(T desired, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT { 3097 // first value becomes desired", all others become 0. 3098 for(auto& c : m_atomics) { 3099 c.atomic.store(desired, order); 3100 desired = {}; 3101 } 3102 } 3103 3104 private: 3105 // Each thread has a different atomic that it operates on. If more than NumLanes threads 3106 // use this, some will use the same atomic. So performance will degrate a bit, but still 3107 // everything will work. 3108 // 3109 // The logic here is a bit tricky. The call should be as fast as possible, so that there 3110 // is minimal to no overhead in determining the correct atomic for the current thread. 3111 // 3112 // 1. A global static counter laneCounter counts continuously up. 3113 // 2. Each successive thread will use modulo operation of that counter so it gets an atomic 3114 // assigned in a round-robin fashion. 3115 // 3. This tlsLaneIdx is stored in the thread local data, so it is directly available with 3116 // little overhead. 3117 std::atomic<T>& myAtomic() DOCTEST_NOEXCEPT { 3118 static std::atomic<size_t> laneCounter; 3119 DOCTEST_THREAD_LOCAL size_t tlsLaneIdx = 3120 laneCounter++ % DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES; 3121 3122 return m_atomics[tlsLaneIdx].atomic; 3123 } 3124 }; 3125 3126 template <typename T> 3127 using AtomicOrMultiLaneAtomic = MultiLaneAtomic<T>; 3128#endif // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS 3129 3130 // this holds both parameters from the command line and runtime data for tests 3131 struct ContextState : ContextOptions, TestRunStats, CurrentTestCaseStats 3132 { 3133 AtomicOrMultiLaneAtomic<int> numAssertsCurrentTest_atomic; 3134 AtomicOrMultiLaneAtomic<int> numAssertsFailedCurrentTest_atomic; 3135 3136 std::vector<std::vector<String>> filters = decltype(filters)(9); // 9 different filters 3137 3138 std::vector<IReporter*> reporters_currently_used; 3139 3140 assert_handler ah = nullptr; 3141 3142 Timer timer; 3143 3144 std::vector<String> stringifiedContexts; // logging from INFO() due to an exception 3145 3146 // stuff for subcases 3147 std::vector<SubcaseSignature> subcasesStack; 3148 std::set<decltype(subcasesStack)> subcasesPassed; 3149 int subcasesCurrentMaxLevel; 3150 bool should_reenter; 3151 std::atomic<bool> shouldLogCurrentException; 3152 3153 void resetRunData() { 3154 numTestCases = 0; 3155 numTestCasesPassingFilters = 0; 3156 numTestSuitesPassingFilters = 0; 3157 numTestCasesFailed = 0; 3158 numAsserts = 0; 3159 numAssertsFailed = 0; 3160 numAssertsCurrentTest = 0; 3161 numAssertsFailedCurrentTest = 0; 3162 } 3163 3164 void finalizeTestCaseData() { 3165 seconds = timer.getElapsedSeconds(); 3166 3167 // update the non-atomic counters 3168 numAsserts += numAssertsCurrentTest_atomic; 3169 numAssertsFailed += numAssertsFailedCurrentTest_atomic; 3170 numAssertsCurrentTest = numAssertsCurrentTest_atomic; 3171 numAssertsFailedCurrentTest = numAssertsFailedCurrentTest_atomic; 3172 3173 if(numAssertsFailedCurrentTest) 3174 failure_flags |= TestCaseFailureReason::AssertFailure; 3175 3176 if(Approx(currentTest->m_timeout).epsilon(DBL_EPSILON) != 0 && 3177 Approx(seconds).epsilon(DBL_EPSILON) > currentTest->m_timeout) 3178 failure_flags |= TestCaseFailureReason::Timeout; 3179 3180 if(currentTest->m_should_fail) { 3181 if(failure_flags) { 3182 failure_flags |= TestCaseFailureReason::ShouldHaveFailedAndDid; 3183 } else { 3184 failure_flags |= TestCaseFailureReason::ShouldHaveFailedButDidnt; 3185 } 3186 } else if(failure_flags && currentTest->m_may_fail) { 3187 failure_flags |= TestCaseFailureReason::CouldHaveFailedAndDid; 3188 } else if(currentTest->m_expected_failures > 0) { 3189 if(numAssertsFailedCurrentTest == currentTest->m_expected_failures) { 3190 failure_flags |= TestCaseFailureReason::FailedExactlyNumTimes; 3191 } else { 3192 failure_flags |= TestCaseFailureReason::DidntFailExactlyNumTimes; 3193 } 3194 } 3195 3196 bool ok_to_fail = (TestCaseFailureReason::ShouldHaveFailedAndDid & failure_flags) || 3197 (TestCaseFailureReason::CouldHaveFailedAndDid & failure_flags) || 3198 (TestCaseFailureReason::FailedExactlyNumTimes & failure_flags); 3199 3200 // if any subcase has failed - the whole test case has failed 3201 if(failure_flags && !ok_to_fail) 3202 numTestCasesFailed++; 3203 } 3204 }; 3205 3206 ContextState* g_cs = nullptr; 3207 3208 // used to avoid locks for the debug output 3209 // TODO: figure out if this is indeed necessary/correct - seems like either there still 3210 // could be a race or that there wouldn't be a race even if using the context directly 3211 DOCTEST_THREAD_LOCAL bool g_no_colors; 3212 3213#endif // DOCTEST_CONFIG_DISABLE 3214} // namespace detail 3215 3216void String::setOnHeap() { *reinterpret_cast<unsigned char*>(&buf[last]) = 128; } 3217void String::setLast(unsigned in) { buf[last] = char(in); } 3218 3219void String::copy(const String& other) { 3220 using namespace std; 3221 if(other.isOnStack()) { 3222 memcpy(buf, other.buf, len); 3223 } else { 3224 setOnHeap(); 3225 data.size = other.data.size; 3226 data.capacity = data.size + 1; 3227 data.ptr = new char[data.capacity]; 3228 memcpy(data.ptr, other.data.ptr, data.size + 1); 3229 } 3230} 3231 3232String::String() { 3233 buf[0] = '\0'; 3234 setLast(); 3235} 3236 3237String::~String() { 3238 if(!isOnStack()) 3239 delete[] data.ptr; 3240 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 3241} 3242 3243String::String(const char* in) 3244 : String(in, strlen(in)) {} 3245 3246String::String(const char* in, unsigned in_size) { 3247 using namespace std; 3248 if(in_size <= last) { 3249 memcpy(buf, in, in_size); 3250 buf[in_size] = '\0'; 3251 setLast(last - in_size); 3252 } else { 3253 setOnHeap(); 3254 data.size = in_size; 3255 data.capacity = data.size + 1; 3256 data.ptr = new char[data.capacity]; 3257 memcpy(data.ptr, in, in_size); 3258 data.ptr[in_size] = '\0'; 3259 } 3260} 3261 3262String::String(const String& other) { copy(other); } 3263 3264String& String::operator=(const String& other) { 3265 if(this != &other) { 3266 if(!isOnStack()) 3267 delete[] data.ptr; 3268 3269 copy(other); 3270 } 3271 3272 return *this; 3273} 3274 3275String& String::operator+=(const String& other) { 3276 const unsigned my_old_size = size(); 3277 const unsigned other_size = other.size(); 3278 const unsigned total_size = my_old_size + other_size; 3279 using namespace std; 3280 if(isOnStack()) { 3281 if(total_size < len) { 3282 // append to the current stack space 3283 memcpy(buf + my_old_size, other.c_str(), other_size + 1); 3284 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 3285 setLast(last - total_size); 3286 } else { 3287 // alloc new chunk 3288 char* temp = new char[total_size + 1]; 3289 // copy current data to new location before writing in the union 3290 memcpy(temp, buf, my_old_size); // skip the +1 ('\0') for speed 3291 // update data in union 3292 setOnHeap(); 3293 data.size = total_size; 3294 data.capacity = data.size + 1; 3295 data.ptr = temp; 3296 // transfer the rest of the data 3297 memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1); 3298 } 3299 } else { 3300 if(data.capacity > total_size) { 3301 // append to the current heap block 3302 data.size = total_size; 3303 memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1); 3304 } else { 3305 // resize 3306 data.capacity *= 2; 3307 if(data.capacity <= total_size) 3308 data.capacity = total_size + 1; 3309 // alloc new chunk 3310 char* temp = new char[data.capacity]; 3311 // copy current data to new location before releasing it 3312 memcpy(temp, data.ptr, my_old_size); // skip the +1 ('\0') for speed 3313 // release old chunk 3314 delete[] data.ptr; 3315 // update the rest of the union members 3316 data.size = total_size; 3317 data.ptr = temp; 3318 // transfer the rest of the data 3319 memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1); 3320 } 3321 } 3322 3323 return *this; 3324} 3325 3326// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 3327String String::operator+(const String& other) const { return String(*this) += other; } 3328 3329String::String(String&& other) { 3330 using namespace std; 3331 memcpy(buf, other.buf, len); 3332 other.buf[0] = '\0'; 3333 other.setLast(); 3334} 3335 3336String& String::operator=(String&& other) { 3337 using namespace std; 3338 if(this != &other) { 3339 if(!isOnStack()) 3340 delete[] data.ptr; 3341 memcpy(buf, other.buf, len); 3342 other.buf[0] = '\0'; 3343 other.setLast(); 3344 } 3345 return *this; 3346} 3347 3348char String::operator[](unsigned i) const { 3349 return const_cast<String*>(this)->operator[](i); // NOLINT 3350} 3351 3352char& String::operator[](unsigned i) { 3353 if(isOnStack()) 3354 return reinterpret_cast<char*>(buf)[i]; 3355 return data.ptr[i]; 3356} 3357 3358DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmaybe-uninitialized") 3359unsigned String::size() const { 3360 if(isOnStack()) 3361 return last - (unsigned(buf[last]) & 31); // using "last" would work only if "len" is 32 3362 return data.size; 3363} 3364DOCTEST_GCC_SUPPRESS_WARNING_POP 3365 3366unsigned String::capacity() const { 3367 if(isOnStack()) 3368 return len; 3369 return data.capacity; 3370} 3371 3372int String::compare(const char* other, bool no_case) const { 3373 if(no_case) 3374 return doctest::stricmp(c_str(), other); 3375 return std::strcmp(c_str(), other); 3376} 3377 3378int String::compare(const String& other, bool no_case) const { 3379 return compare(other.c_str(), no_case); 3380} 3381 3382// clang-format off 3383bool operator==(const String& lhs, const String& rhs) { return lhs.compare(rhs) == 0; } 3384bool operator!=(const String& lhs, const String& rhs) { return lhs.compare(rhs) != 0; } 3385bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; } 3386bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; } 3387bool operator<=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) < 0 : true; } 3388bool operator>=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) > 0 : true; } 3389// clang-format on 3390 3391std::ostream& operator<<(std::ostream& s, const String& in) { return s << in.c_str(); } 3392 3393namespace { 3394 void color_to_stream(std::ostream&, Color::Enum) DOCTEST_BRANCH_ON_DISABLED({}, ;) 3395} // namespace 3396 3397namespace Color { 3398 std::ostream& operator<<(std::ostream& s, Color::Enum code) { 3399 color_to_stream(s, code); 3400 return s; 3401 } 3402} // namespace Color 3403 3404// clang-format off 3405const char* assertString(assertType::Enum at) { 3406 DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4062) // enum 'x' in switch of enum 'y' is not handled 3407 switch(at) { //!OCLINT missing default in switch statements 3408 case assertType::DT_WARN : return "WARN"; 3409 case assertType::DT_CHECK : return "CHECK"; 3410 case assertType::DT_REQUIRE : return "REQUIRE"; 3411 3412 case assertType::DT_WARN_FALSE : return "WARN_FALSE"; 3413 case assertType::DT_CHECK_FALSE : return "CHECK_FALSE"; 3414 case assertType::DT_REQUIRE_FALSE : return "REQUIRE_FALSE"; 3415 3416 case assertType::DT_WARN_THROWS : return "WARN_THROWS"; 3417 case assertType::DT_CHECK_THROWS : return "CHECK_THROWS"; 3418 case assertType::DT_REQUIRE_THROWS : return "REQUIRE_THROWS"; 3419 3420 case assertType::DT_WARN_THROWS_AS : return "WARN_THROWS_AS"; 3421 case assertType::DT_CHECK_THROWS_AS : return "CHECK_THROWS_AS"; 3422 case assertType::DT_REQUIRE_THROWS_AS : return "REQUIRE_THROWS_AS"; 3423 3424 case assertType::DT_WARN_THROWS_WITH : return "WARN_THROWS_WITH"; 3425 case assertType::DT_CHECK_THROWS_WITH : return "CHECK_THROWS_WITH"; 3426 case assertType::DT_REQUIRE_THROWS_WITH : return "REQUIRE_THROWS_WITH"; 3427 3428 case assertType::DT_WARN_THROWS_WITH_AS : return "WARN_THROWS_WITH_AS"; 3429 case assertType::DT_CHECK_THROWS_WITH_AS : return "CHECK_THROWS_WITH_AS"; 3430 case assertType::DT_REQUIRE_THROWS_WITH_AS : return "REQUIRE_THROWS_WITH_AS"; 3431 3432 case assertType::DT_WARN_NOTHROW : return "WARN_NOTHROW"; 3433 case assertType::DT_CHECK_NOTHROW : return "CHECK_NOTHROW"; 3434 case assertType::DT_REQUIRE_NOTHROW : return "REQUIRE_NOTHROW"; 3435 3436 case assertType::DT_WARN_EQ : return "WARN_EQ"; 3437 case assertType::DT_CHECK_EQ : return "CHECK_EQ"; 3438 case assertType::DT_REQUIRE_EQ : return "REQUIRE_EQ"; 3439 case assertType::DT_WARN_NE : return "WARN_NE"; 3440 case assertType::DT_CHECK_NE : return "CHECK_NE"; 3441 case assertType::DT_REQUIRE_NE : return "REQUIRE_NE"; 3442 case assertType::DT_WARN_GT : return "WARN_GT"; 3443 case assertType::DT_CHECK_GT : return "CHECK_GT"; 3444 case assertType::DT_REQUIRE_GT : return "REQUIRE_GT"; 3445 case assertType::DT_WARN_LT : return "WARN_LT"; 3446 case assertType::DT_CHECK_LT : return "CHECK_LT"; 3447 case assertType::DT_REQUIRE_LT : return "REQUIRE_LT"; 3448 case assertType::DT_WARN_GE : return "WARN_GE"; 3449 case assertType::DT_CHECK_GE : return "CHECK_GE"; 3450 case assertType::DT_REQUIRE_GE : return "REQUIRE_GE"; 3451 case assertType::DT_WARN_LE : return "WARN_LE"; 3452 case assertType::DT_CHECK_LE : return "CHECK_LE"; 3453 case assertType::DT_REQUIRE_LE : return "REQUIRE_LE"; 3454 3455 case assertType::DT_WARN_UNARY : return "WARN_UNARY"; 3456 case assertType::DT_CHECK_UNARY : return "CHECK_UNARY"; 3457 case assertType::DT_REQUIRE_UNARY : return "REQUIRE_UNARY"; 3458 case assertType::DT_WARN_UNARY_FALSE : return "WARN_UNARY_FALSE"; 3459 case assertType::DT_CHECK_UNARY_FALSE : return "CHECK_UNARY_FALSE"; 3460 case assertType::DT_REQUIRE_UNARY_FALSE : return "REQUIRE_UNARY_FALSE"; 3461 } 3462 DOCTEST_MSVC_SUPPRESS_WARNING_POP 3463 return ""; 3464} 3465// clang-format on 3466 3467const char* failureString(assertType::Enum at) { 3468 if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional 3469 return "WARNING"; 3470 if(at & assertType::is_check) //!OCLINT bitwise operator in conditional 3471 return "ERROR"; 3472 if(at & assertType::is_require) //!OCLINT bitwise operator in conditional 3473 return "FATAL ERROR"; 3474 return ""; 3475} 3476 3477DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference") 3478DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference") 3479// depending on the current options this will remove the path of filenames 3480const char* skipPathFromFilename(const char* file) { 3481#ifndef DOCTEST_CONFIG_DISABLE 3482 if(getContextOptions()->no_path_in_filenames) { 3483 auto back = std::strrchr(file, '\\'); 3484 auto forward = std::strrchr(file, '/'); 3485 if(back || forward) { 3486 if(back > forward) 3487 forward = back; 3488 return forward + 1; 3489 } 3490 } 3491#endif // DOCTEST_CONFIG_DISABLE 3492 return file; 3493} 3494DOCTEST_CLANG_SUPPRESS_WARNING_POP 3495DOCTEST_GCC_SUPPRESS_WARNING_POP 3496 3497bool SubcaseSignature::operator<(const SubcaseSignature& other) const { 3498 if(m_line != other.m_line) 3499 return m_line < other.m_line; 3500 if(std::strcmp(m_file, other.m_file) != 0) 3501 return std::strcmp(m_file, other.m_file) < 0; 3502 return m_name.compare(other.m_name) < 0; 3503} 3504 3505IContextScope::IContextScope() = default; 3506IContextScope::~IContextScope() = default; 3507 3508#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 3509String toString(char* in) { return toString(static_cast<const char*>(in)); } 3510// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 3511String toString(const char* in) { return String("\"") + (in ? in : "{null string}") + "\""; } 3512#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 3513String toString(bool in) { return in ? "true" : "false"; } 3514String toString(float in) { return fpToString(in, 5) + "f"; } 3515String toString(double in) { return fpToString(in, 10); } 3516String toString(double long in) { return fpToString(in, 15); } 3517 3518#define DOCTEST_TO_STRING_OVERLOAD(type, fmt) \ 3519 String toString(type in) { \ 3520 char buf[64]; \ 3521 std::sprintf(buf, fmt, in); \ 3522 return buf; \ 3523 } 3524 3525DOCTEST_TO_STRING_OVERLOAD(char, "%d") 3526DOCTEST_TO_STRING_OVERLOAD(char signed, "%d") 3527DOCTEST_TO_STRING_OVERLOAD(char unsigned, "%u") 3528DOCTEST_TO_STRING_OVERLOAD(int short, "%d") 3529DOCTEST_TO_STRING_OVERLOAD(int short unsigned, "%u") 3530DOCTEST_TO_STRING_OVERLOAD(int, "%d") 3531DOCTEST_TO_STRING_OVERLOAD(unsigned, "%u") 3532DOCTEST_TO_STRING_OVERLOAD(int long, "%ld") 3533DOCTEST_TO_STRING_OVERLOAD(int long unsigned, "%lu") 3534DOCTEST_TO_STRING_OVERLOAD(int long long, "%lld") 3535DOCTEST_TO_STRING_OVERLOAD(int long long unsigned, "%llu") 3536 3537String toString(std::nullptr_t) { return "NULL"; } 3538 3539#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0) 3540// see this issue on why this is needed: https://github.com/onqtam/doctest/issues/183 3541String toString(const std::string& in) { return in.c_str(); } 3542#endif // VS 2019 3543 3544Approx::Approx(double value) 3545 : m_epsilon(static_cast<double>(std::numeric_limits<float>::epsilon()) * 100) 3546 , m_scale(1.0) 3547 , m_value(value) {} 3548 3549Approx Approx::operator()(double value) const { 3550 Approx approx(value); 3551 approx.epsilon(m_epsilon); 3552 approx.scale(m_scale); 3553 return approx; 3554} 3555 3556Approx& Approx::epsilon(double newEpsilon) { 3557 m_epsilon = newEpsilon; 3558 return *this; 3559} 3560Approx& Approx::scale(double newScale) { 3561 m_scale = newScale; 3562 return *this; 3563} 3564 3565bool operator==(double lhs, const Approx& rhs) { 3566 // Thanks to Richard Harris for his help refining this formula 3567 return std::fabs(lhs - rhs.m_value) < 3568 rhs.m_epsilon * (rhs.m_scale + std::max<double>(std::fabs(lhs), std::fabs(rhs.m_value))); 3569} 3570bool operator==(const Approx& lhs, double rhs) { return operator==(rhs, lhs); } 3571bool operator!=(double lhs, const Approx& rhs) { return !operator==(lhs, rhs); } 3572bool operator!=(const Approx& lhs, double rhs) { return !operator==(rhs, lhs); } 3573bool operator<=(double lhs, const Approx& rhs) { return lhs < rhs.m_value || lhs == rhs; } 3574bool operator<=(const Approx& lhs, double rhs) { return lhs.m_value < rhs || lhs == rhs; } 3575bool operator>=(double lhs, const Approx& rhs) { return lhs > rhs.m_value || lhs == rhs; } 3576bool operator>=(const Approx& lhs, double rhs) { return lhs.m_value > rhs || lhs == rhs; } 3577bool operator<(double lhs, const Approx& rhs) { return lhs < rhs.m_value && lhs != rhs; } 3578bool operator<(const Approx& lhs, double rhs) { return lhs.m_value < rhs && lhs != rhs; } 3579bool operator>(double lhs, const Approx& rhs) { return lhs > rhs.m_value && lhs != rhs; } 3580bool operator>(const Approx& lhs, double rhs) { return lhs.m_value > rhs && lhs != rhs; } 3581 3582String toString(const Approx& in) { 3583 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 3584 return String("Approx( ") + doctest::toString(in.m_value) + " )"; 3585} 3586const ContextOptions* getContextOptions() { return DOCTEST_BRANCH_ON_DISABLED(nullptr, g_cs); } 3587 3588} // namespace doctest 3589 3590#ifdef DOCTEST_CONFIG_DISABLE 3591namespace doctest { 3592Context::Context(int, const char* const*) {} 3593Context::~Context() = default; 3594void Context::applyCommandLine(int, const char* const*) {} 3595void Context::addFilter(const char*, const char*) {} 3596void Context::clearFilters() {} 3597void Context::setOption(const char*, int) {} 3598void Context::setOption(const char*, const char*) {} 3599bool Context::shouldExit() { return false; } 3600void Context::setAsDefaultForAssertsOutOfTestCases() {} 3601void Context::setAssertHandler(detail::assert_handler) {} 3602int Context::run() { return 0; } 3603 3604IReporter::~IReporter() = default; 3605 3606int IReporter::get_num_active_contexts() { return 0; } 3607const IContextScope* const* IReporter::get_active_contexts() { return nullptr; } 3608int IReporter::get_num_stringified_contexts() { return 0; } 3609const String* IReporter::get_stringified_contexts() { return nullptr; } 3610 3611int registerReporter(const char*, int, IReporter*) { return 0; } 3612 3613} // namespace doctest 3614#else // DOCTEST_CONFIG_DISABLE 3615 3616#if !defined(DOCTEST_CONFIG_COLORS_NONE) 3617#if !defined(DOCTEST_CONFIG_COLORS_WINDOWS) && !defined(DOCTEST_CONFIG_COLORS_ANSI) 3618#ifdef DOCTEST_PLATFORM_WINDOWS 3619#define DOCTEST_CONFIG_COLORS_WINDOWS 3620#else // linux 3621#define DOCTEST_CONFIG_COLORS_ANSI 3622#endif // platform 3623#endif // DOCTEST_CONFIG_COLORS_WINDOWS && DOCTEST_CONFIG_COLORS_ANSI 3624#endif // DOCTEST_CONFIG_COLORS_NONE 3625 3626namespace doctest_detail_test_suite_ns { 3627// holds the current test suite 3628doctest::detail::TestSuite& getCurrentTestSuite() { 3629 static doctest::detail::TestSuite data{}; 3630 return data; 3631} 3632} // namespace doctest_detail_test_suite_ns 3633 3634namespace doctest { 3635namespace { 3636 // the int (priority) is part of the key for automatic sorting - sadly one can register a 3637 // reporter with a duplicate name and a different priority but hopefully that won't happen often :| 3638 typedef std::map<std::pair<int, String>, reporterCreatorFunc> reporterMap; 3639 3640 reporterMap& getReporters() { 3641 static reporterMap data; 3642 return data; 3643 } 3644 reporterMap& getListeners() { 3645 static reporterMap data; 3646 return data; 3647 } 3648} // namespace 3649namespace detail { 3650#define DOCTEST_ITERATE_THROUGH_REPORTERS(function, ...) \ 3651 for(auto& curr_rep : g_cs->reporters_currently_used) \ 3652 curr_rep->function(__VA_ARGS__) 3653 3654 bool checkIfShouldThrow(assertType::Enum at) { 3655 if(at & assertType::is_require) //!OCLINT bitwise operator in conditional 3656 return true; 3657 3658 if((at & assertType::is_check) //!OCLINT bitwise operator in conditional 3659 && getContextOptions()->abort_after > 0 && 3660 (g_cs->numAssertsFailed + g_cs->numAssertsFailedCurrentTest_atomic) >= 3661 getContextOptions()->abort_after) 3662 return true; 3663 3664 return false; 3665 } 3666 3667#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 3668 DOCTEST_NORETURN void throwException() { 3669 g_cs->shouldLogCurrentException = false; 3670 throw TestFailureException(); 3671 } // NOLINT(cert-err60-cpp) 3672#else // DOCTEST_CONFIG_NO_EXCEPTIONS 3673 void throwException() {} 3674#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 3675} // namespace detail 3676 3677namespace { 3678 using namespace detail; 3679 // matching of a string against a wildcard mask (case sensitivity configurable) taken from 3680 // https://www.codeproject.com/Articles/1088/Wildcard-string-compare-globbing 3681 int wildcmp(const char* str, const char* wild, bool caseSensitive) { 3682 const char* cp = str; 3683 const char* mp = wild; 3684 3685 while((*str) && (*wild != '*')) { 3686 if((caseSensitive ? (*wild != *str) : (tolower(*wild) != tolower(*str))) && 3687 (*wild != '?')) { 3688 return 0; 3689 } 3690 wild++; 3691 str++; 3692 } 3693 3694 while(*str) { 3695 if(*wild == '*') { 3696 if(!*++wild) { 3697 return 1; 3698 } 3699 mp = wild; 3700 cp = str + 1; 3701 } else if((caseSensitive ? (*wild == *str) : (tolower(*wild) == tolower(*str))) || 3702 (*wild == '?')) { 3703 wild++; 3704 str++; 3705 } else { 3706 wild = mp; //!OCLINT parameter reassignment 3707 str = cp++; //!OCLINT parameter reassignment 3708 } 3709 } 3710 3711 while(*wild == '*') { 3712 wild++; 3713 } 3714 return !*wild; 3715 } 3716 3717 //// C string hash function (djb2) - taken from http://www.cse.yorku.ca/~oz/hash.html 3718 //unsigned hashStr(unsigned const char* str) { 3719 // unsigned long hash = 5381; 3720 // char c; 3721 // while((c = *str++)) 3722 // hash = ((hash << 5) + hash) + c; // hash * 33 + c 3723 // return hash; 3724 //} 3725 3726 // checks if the name matches any of the filters (and can be configured what to do when empty) 3727 bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty, 3728 bool caseSensitive) { 3729 if(filters.empty() && matchEmpty) 3730 return true; 3731 for(auto& curr : filters) 3732 if(wildcmp(name, curr.c_str(), caseSensitive)) 3733 return true; 3734 return false; 3735 } 3736} // namespace 3737namespace detail { 3738 3739 Subcase::Subcase(const String& name, const char* file, int line) 3740 : m_signature({name, file, line}) { 3741 auto* s = g_cs; 3742 3743 // check subcase filters 3744 if(s->subcasesStack.size() < size_t(s->subcase_filter_levels)) { 3745 if(!matchesAny(m_signature.m_name.c_str(), s->filters[6], true, s->case_sensitive)) 3746 return; 3747 if(matchesAny(m_signature.m_name.c_str(), s->filters[7], false, s->case_sensitive)) 3748 return; 3749 } 3750 3751 // if a Subcase on the same level has already been entered 3752 if(s->subcasesStack.size() < size_t(s->subcasesCurrentMaxLevel)) { 3753 s->should_reenter = true; 3754 return; 3755 } 3756 3757 // push the current signature to the stack so we can check if the 3758 // current stack + the current new subcase have been traversed 3759 s->subcasesStack.push_back(m_signature); 3760 if(s->subcasesPassed.count(s->subcasesStack) != 0) { 3761 // pop - revert to previous stack since we've already passed this 3762 s->subcasesStack.pop_back(); 3763 return; 3764 } 3765 3766 s->subcasesCurrentMaxLevel = s->subcasesStack.size(); 3767 m_entered = true; 3768 3769 DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature); 3770 } 3771 3772 DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17 3773 DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations") 3774 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations") 3775 3776 Subcase::~Subcase() { 3777 if(m_entered) { 3778 // only mark the subcase stack as passed if no subcases have been skipped 3779 if(g_cs->should_reenter == false) 3780 g_cs->subcasesPassed.insert(g_cs->subcasesStack); 3781 g_cs->subcasesStack.pop_back(); 3782 3783#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200) 3784 if(std::uncaught_exceptions() > 0 3785#else 3786 if(std::uncaught_exception() 3787#endif 3788 && g_cs->shouldLogCurrentException) { 3789 DOCTEST_ITERATE_THROUGH_REPORTERS( 3790 test_case_exception, {"exception thrown in subcase - will translate later " 3791 "when the whole test case has been exited (cannot " 3792 "translate while there is an active exception)", 3793 false}); 3794 g_cs->shouldLogCurrentException = false; 3795 } 3796 DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY); 3797 } 3798 } 3799 3800 DOCTEST_CLANG_SUPPRESS_WARNING_POP 3801 DOCTEST_GCC_SUPPRESS_WARNING_POP 3802 DOCTEST_MSVC_SUPPRESS_WARNING_POP 3803 3804 Subcase::operator bool() const { return m_entered; } 3805 3806 Result::Result(bool passed, const String& decomposition) 3807 : m_passed(passed) 3808 , m_decomp(decomposition) {} 3809 3810 ExpressionDecomposer::ExpressionDecomposer(assertType::Enum at) 3811 : m_at(at) {} 3812 3813 TestSuite& TestSuite::operator*(const char* in) { 3814 m_test_suite = in; 3815 // clear state 3816 m_description = nullptr; 3817 m_skip = false; 3818 m_no_breaks = false; 3819 m_no_output = false; 3820 m_may_fail = false; 3821 m_should_fail = false; 3822 m_expected_failures = 0; 3823 m_timeout = 0; 3824 return *this; 3825 } 3826 3827 TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite, 3828 const char* type, int template_id) { 3829 m_file = file; 3830 m_line = line; 3831 m_name = nullptr; // will be later overridden in operator* 3832 m_test_suite = test_suite.m_test_suite; 3833 m_description = test_suite.m_description; 3834 m_skip = test_suite.m_skip; 3835 m_no_breaks = test_suite.m_no_breaks; 3836 m_no_output = test_suite.m_no_output; 3837 m_may_fail = test_suite.m_may_fail; 3838 m_should_fail = test_suite.m_should_fail; 3839 m_expected_failures = test_suite.m_expected_failures; 3840 m_timeout = test_suite.m_timeout; 3841 3842 m_test = test; 3843 m_type = type; 3844 m_template_id = template_id; 3845 } 3846 3847 TestCase::TestCase(const TestCase& other) 3848 : TestCaseData() { 3849 *this = other; 3850 } 3851 3852 DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function 3853 DOCTEST_MSVC_SUPPRESS_WARNING(26437) // Do not slice 3854 TestCase& TestCase::operator=(const TestCase& other) { 3855 static_cast<TestCaseData&>(*this) = static_cast<const TestCaseData&>(other); 3856 3857 m_test = other.m_test; 3858 m_type = other.m_type; 3859 m_template_id = other.m_template_id; 3860 m_full_name = other.m_full_name; 3861 3862 if(m_template_id != -1) 3863 m_name = m_full_name.c_str(); 3864 return *this; 3865 } 3866 DOCTEST_MSVC_SUPPRESS_WARNING_POP 3867 3868 TestCase& TestCase::operator*(const char* in) { 3869 m_name = in; 3870 // make a new name with an appended type for templated test case 3871 if(m_template_id != -1) { 3872 m_full_name = String(m_name) + m_type; 3873 // redirect the name to point to the newly constructed full name 3874 m_name = m_full_name.c_str(); 3875 } 3876 return *this; 3877 } 3878 3879 bool TestCase::operator<(const TestCase& other) const { 3880 // this will be used only to differentiate between test cases - not relevant for sorting 3881 if(m_line != other.m_line) 3882 return m_line < other.m_line; 3883 const int name_cmp = strcmp(m_name, other.m_name); 3884 if(name_cmp != 0) 3885 return name_cmp < 0; 3886 const int file_cmp = m_file.compare(other.m_file); 3887 if(file_cmp != 0) 3888 return file_cmp < 0; 3889 return m_template_id < other.m_template_id; 3890 } 3891 3892 // all the registered tests 3893 std::set<TestCase>& getRegisteredTests() { 3894 static std::set<TestCase> data; 3895 return data; 3896 } 3897} // namespace detail 3898namespace { 3899 using namespace detail; 3900 // for sorting tests by file/line 3901 bool fileOrderComparator(const TestCase* lhs, const TestCase* rhs) { 3902 // this is needed because MSVC gives different case for drive letters 3903 // for __FILE__ when evaluated in a header and a source file 3904 const int res = lhs->m_file.compare(rhs->m_file, bool(DOCTEST_MSVC)); 3905 if(res != 0) 3906 return res < 0; 3907 if(lhs->m_line != rhs->m_line) 3908 return lhs->m_line < rhs->m_line; 3909 return lhs->m_template_id < rhs->m_template_id; 3910 } 3911 3912 // for sorting tests by suite/file/line 3913 bool suiteOrderComparator(const TestCase* lhs, const TestCase* rhs) { 3914 const int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite); 3915 if(res != 0) 3916 return res < 0; 3917 return fileOrderComparator(lhs, rhs); 3918 } 3919 3920 // for sorting tests by name/suite/file/line 3921 bool nameOrderComparator(const TestCase* lhs, const TestCase* rhs) { 3922 const int res = std::strcmp(lhs->m_name, rhs->m_name); 3923 if(res != 0) 3924 return res < 0; 3925 return suiteOrderComparator(lhs, rhs); 3926 } 3927 3928#ifdef DOCTEST_CONFIG_COLORS_WINDOWS 3929 HANDLE g_stdoutHandle; 3930 WORD g_origFgAttrs; 3931 WORD g_origBgAttrs; 3932 bool g_attrsInitted = false; 3933 3934 int colors_init() { 3935 if(!g_attrsInitted) { 3936 g_stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE); 3937 g_attrsInitted = true; 3938 CONSOLE_SCREEN_BUFFER_INFO csbiInfo; 3939 GetConsoleScreenBufferInfo(g_stdoutHandle, &csbiInfo); 3940 g_origFgAttrs = csbiInfo.wAttributes & ~(BACKGROUND_GREEN | BACKGROUND_RED | 3941 BACKGROUND_BLUE | BACKGROUND_INTENSITY); 3942 g_origBgAttrs = csbiInfo.wAttributes & ~(FOREGROUND_GREEN | FOREGROUND_RED | 3943 FOREGROUND_BLUE | FOREGROUND_INTENSITY); 3944 } 3945 return 0; 3946 } 3947 3948 int dumy_init_console_colors = colors_init(); 3949#endif // DOCTEST_CONFIG_COLORS_WINDOWS 3950 3951 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations") 3952 void color_to_stream(std::ostream& s, Color::Enum code) { 3953 static_cast<void>(s); // for DOCTEST_CONFIG_COLORS_NONE or DOCTEST_CONFIG_COLORS_WINDOWS 3954 static_cast<void>(code); // for DOCTEST_CONFIG_COLORS_NONE 3955#ifdef DOCTEST_CONFIG_COLORS_ANSI 3956 if(g_no_colors || 3957 (isatty(STDOUT_FILENO) == false && getContextOptions()->force_colors == false)) 3958 return; 3959 3960 auto col = ""; 3961 // clang-format off 3962 switch(code) { //!OCLINT missing break in switch statement / unnecessary default statement in covered switch statement 3963 case Color::Red: col = "[0;31m"; break; 3964 case Color::Green: col = "[0;32m"; break; 3965 case Color::Blue: col = "[0;34m"; break; 3966 case Color::Cyan: col = "[0;36m"; break; 3967 case Color::Yellow: col = "[0;33m"; break; 3968 case Color::Grey: col = "[1;30m"; break; 3969 case Color::LightGrey: col = "[0;37m"; break; 3970 case Color::BrightRed: col = "[1;31m"; break; 3971 case Color::BrightGreen: col = "[1;32m"; break; 3972 case Color::BrightWhite: col = "[1;37m"; break; 3973 case Color::Bright: // invalid 3974 case Color::None: 3975 case Color::White: 3976 default: col = "[0m"; 3977 } 3978 // clang-format on 3979 s << "\033" << col; 3980#endif // DOCTEST_CONFIG_COLORS_ANSI 3981 3982#ifdef DOCTEST_CONFIG_COLORS_WINDOWS 3983 if(g_no_colors || 3984 (isatty(fileno(stdout)) == false && getContextOptions()->force_colors == false)) 3985 return; 3986 3987#define DOCTEST_SET_ATTR(x) SetConsoleTextAttribute(g_stdoutHandle, x | g_origBgAttrs) 3988 3989 // clang-format off 3990 switch (code) { 3991 case Color::White: DOCTEST_SET_ATTR(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break; 3992 case Color::Red: DOCTEST_SET_ATTR(FOREGROUND_RED); break; 3993 case Color::Green: DOCTEST_SET_ATTR(FOREGROUND_GREEN); break; 3994 case Color::Blue: DOCTEST_SET_ATTR(FOREGROUND_BLUE); break; 3995 case Color::Cyan: DOCTEST_SET_ATTR(FOREGROUND_BLUE | FOREGROUND_GREEN); break; 3996 case Color::Yellow: DOCTEST_SET_ATTR(FOREGROUND_RED | FOREGROUND_GREEN); break; 3997 case Color::Grey: DOCTEST_SET_ATTR(0); break; 3998 case Color::LightGrey: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY); break; 3999 case Color::BrightRed: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_RED); break; 4000 case Color::BrightGreen: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN); break; 4001 case Color::BrightWhite: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break; 4002 case Color::None: 4003 case Color::Bright: // invalid 4004 default: DOCTEST_SET_ATTR(g_origFgAttrs); 4005 } 4006 // clang-format on 4007#endif // DOCTEST_CONFIG_COLORS_WINDOWS 4008 } 4009 DOCTEST_CLANG_SUPPRESS_WARNING_POP 4010 4011 std::vector<const IExceptionTranslator*>& getExceptionTranslators() { 4012 static std::vector<const IExceptionTranslator*> data; 4013 return data; 4014 } 4015 4016 String translateActiveException() { 4017#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 4018 String res; 4019 auto& translators = getExceptionTranslators(); 4020 for(auto& curr : translators) 4021 if(curr->translate(res)) 4022 return res; 4023 // clang-format off 4024 DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wcatch-value") 4025 try { 4026 throw; 4027 } catch(std::exception& ex) { 4028 return ex.what(); 4029 } catch(std::string& msg) { 4030 return msg.c_str(); 4031 } catch(const char* msg) { 4032 return msg; 4033 } catch(...) { 4034 return "unknown exception"; 4035 } 4036 DOCTEST_GCC_SUPPRESS_WARNING_POP 4037// clang-format on 4038#else // DOCTEST_CONFIG_NO_EXCEPTIONS 4039 return ""; 4040#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 4041 } 4042} // namespace 4043 4044namespace detail { 4045 // used by the macros for registering tests 4046 int regTest(const TestCase& tc) { 4047 getRegisteredTests().insert(tc); 4048 return 0; 4049 } 4050 4051 // sets the current test suite 4052 int setTestSuite(const TestSuite& ts) { 4053 doctest_detail_test_suite_ns::getCurrentTestSuite() = ts; 4054 return 0; 4055 } 4056 4057#ifdef DOCTEST_IS_DEBUGGER_ACTIVE 4058 bool isDebuggerActive() { return DOCTEST_IS_DEBUGGER_ACTIVE(); } 4059#else // DOCTEST_IS_DEBUGGER_ACTIVE 4060#ifdef DOCTEST_PLATFORM_LINUX 4061 class ErrnoGuard { 4062 public: 4063 ErrnoGuard() : m_oldErrno(errno) {} 4064 ~ErrnoGuard() { errno = m_oldErrno; } 4065 private: 4066 int m_oldErrno; 4067 }; 4068 // See the comments in Catch2 for the reasoning behind this implementation: 4069 // https://github.com/catchorg/Catch2/blob/v2.13.1/include/internal/catch_debugger.cpp#L79-L102 4070 bool isDebuggerActive() { 4071 ErrnoGuard guard; 4072 std::ifstream in("/proc/self/status"); 4073 for(std::string line; std::getline(in, line);) { 4074 static const int PREFIX_LEN = 11; 4075 if(line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0) { 4076 return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0'; 4077 } 4078 } 4079 return false; 4080 } 4081#elif defined(DOCTEST_PLATFORM_MAC) 4082 // The following function is taken directly from the following technical note: 4083 // https://developer.apple.com/library/archive/qa/qa1361/_index.html 4084 // Returns true if the current process is being debugged (either 4085 // running under the debugger or has a debugger attached post facto). 4086 bool isDebuggerActive() { 4087 int mib[4]; 4088 kinfo_proc info; 4089 size_t size; 4090 // Initialize the flags so that, if sysctl fails for some bizarre 4091 // reason, we get a predictable result. 4092 info.kp_proc.p_flag = 0; 4093 // Initialize mib, which tells sysctl the info we want, in this case 4094 // we're looking for information about a specific process ID. 4095 mib[0] = CTL_KERN; 4096 mib[1] = KERN_PROC; 4097 mib[2] = KERN_PROC_PID; 4098 mib[3] = getpid(); 4099 // Call sysctl. 4100 size = sizeof(info); 4101 if(sysctl(mib, DOCTEST_COUNTOF(mib), &info, &size, 0, 0) != 0) { 4102 std::cerr << "\nCall to sysctl failed - unable to determine if debugger is active **\n"; 4103 return false; 4104 } 4105 // We're being debugged if the P_TRACED flag is set. 4106 return ((info.kp_proc.p_flag & P_TRACED) != 0); 4107 } 4108#elif DOCTEST_MSVC || defined(__MINGW32__) || defined(__MINGW64__) 4109 bool isDebuggerActive() { return ::IsDebuggerPresent() != 0; } 4110#else 4111 bool isDebuggerActive() { return false; } 4112#endif // Platform 4113#endif // DOCTEST_IS_DEBUGGER_ACTIVE 4114 4115 void registerExceptionTranslatorImpl(const IExceptionTranslator* et) { 4116 if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) == 4117 getExceptionTranslators().end()) 4118 getExceptionTranslators().push_back(et); 4119 } 4120 4121#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 4122 void toStream(std::ostream* s, char* in) { *s << in; } 4123 void toStream(std::ostream* s, const char* in) { *s << in; } 4124#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING 4125 void toStream(std::ostream* s, bool in) { *s << std::boolalpha << in << std::noboolalpha; } 4126 void toStream(std::ostream* s, float in) { *s << in; } 4127 void toStream(std::ostream* s, double in) { *s << in; } 4128 void toStream(std::ostream* s, double long in) { *s << in; } 4129 4130 void toStream(std::ostream* s, char in) { *s << in; } 4131 void toStream(std::ostream* s, char signed in) { *s << in; } 4132 void toStream(std::ostream* s, char unsigned in) { *s << in; } 4133 void toStream(std::ostream* s, int short in) { *s << in; } 4134 void toStream(std::ostream* s, int short unsigned in) { *s << in; } 4135 void toStream(std::ostream* s, int in) { *s << in; } 4136 void toStream(std::ostream* s, int unsigned in) { *s << in; } 4137 void toStream(std::ostream* s, int long in) { *s << in; } 4138 void toStream(std::ostream* s, int long unsigned in) { *s << in; } 4139 void toStream(std::ostream* s, int long long in) { *s << in; } 4140 void toStream(std::ostream* s, int long long unsigned in) { *s << in; } 4141 4142 DOCTEST_THREAD_LOCAL std::vector<IContextScope*> g_infoContexts; // for logging with INFO() 4143 4144 ContextScopeBase::ContextScopeBase() { 4145 g_infoContexts.push_back(this); 4146 } 4147 4148 DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17 4149 DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations") 4150 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations") 4151 4152 // destroy cannot be inlined into the destructor because that would mean calling stringify after 4153 // ContextScope has been destroyed (base class destructors run after derived class destructors). 4154 // Instead, ContextScope calls this method directly from its destructor. 4155 void ContextScopeBase::destroy() { 4156#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200) 4157 if(std::uncaught_exceptions() > 0) { 4158#else 4159 if(std::uncaught_exception()) { 4160#endif 4161 std::ostringstream s; 4162 this->stringify(&s); 4163 g_cs->stringifiedContexts.push_back(s.str().c_str()); 4164 } 4165 g_infoContexts.pop_back(); 4166 } 4167 4168 DOCTEST_CLANG_SUPPRESS_WARNING_POP 4169 DOCTEST_GCC_SUPPRESS_WARNING_POP 4170 DOCTEST_MSVC_SUPPRESS_WARNING_POP 4171} // namespace detail 4172namespace { 4173 using namespace detail; 4174 4175#if !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && !defined(DOCTEST_CONFIG_WINDOWS_SEH) 4176 struct FatalConditionHandler 4177 { 4178 static void reset() {} 4179 static void allocateAltStackMem() {} 4180 static void freeAltStackMem() {} 4181 }; 4182#else // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH 4183 4184 void reportFatal(const std::string&); 4185 4186#ifdef DOCTEST_PLATFORM_WINDOWS 4187 4188 struct SignalDefs 4189 { 4190 DWORD id; 4191 const char* name; 4192 }; 4193 // There is no 1-1 mapping between signals and windows exceptions. 4194 // Windows can easily distinguish between SO and SigSegV, 4195 // but SigInt, SigTerm, etc are handled differently. 4196 SignalDefs signalDefs[] = { 4197 {static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION), 4198 "SIGILL - Illegal instruction signal"}, 4199 {static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow"}, 4200 {static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), 4201 "SIGSEGV - Segmentation violation signal"}, 4202 {static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error"}, 4203 }; 4204 4205 struct FatalConditionHandler 4206 { 4207 static LONG CALLBACK handleException(PEXCEPTION_POINTERS ExceptionInfo) { 4208 // Multiple threads may enter this filter/handler at once. We want the error message to be printed on the 4209 // console just once no matter how many threads have crashed. 4210 static std::mutex mutex; 4211 static bool execute = true; 4212 { 4213 std::lock_guard<std::mutex> lock(mutex); 4214 if(execute) { 4215 bool reported = false; 4216 for(size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) { 4217 if(ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) { 4218 reportFatal(signalDefs[i].name); 4219 reported = true; 4220 break; 4221 } 4222 } 4223 if(reported == false) 4224 reportFatal("Unhandled SEH exception caught"); 4225 if(isDebuggerActive() && !g_cs->no_breaks) 4226 DOCTEST_BREAK_INTO_DEBUGGER(); 4227 } 4228 execute = false; 4229 } 4230 std::exit(EXIT_FAILURE); 4231 } 4232 4233 static void allocateAltStackMem() {} 4234 static void freeAltStackMem() {} 4235 4236 FatalConditionHandler() { 4237 isSet = true; 4238 // 32k seems enough for doctest to handle stack overflow, 4239 // but the value was found experimentally, so there is no strong guarantee 4240 guaranteeSize = 32 * 1024; 4241 // Register an unhandled exception filter 4242 previousTop = SetUnhandledExceptionFilter(handleException); 4243 // Pass in guarantee size to be filled 4244 SetThreadStackGuarantee(&guaranteeSize); 4245 4246 // On Windows uncaught exceptions from another thread, exceptions from 4247 // destructors, or calls to std::terminate are not a SEH exception 4248 4249 // The terminal handler gets called when: 4250 // - std::terminate is called FROM THE TEST RUNNER THREAD 4251 // - an exception is thrown from a destructor FROM THE TEST RUNNER THREAD 4252 original_terminate_handler = std::get_terminate(); 4253 std::set_terminate([]() DOCTEST_NOEXCEPT { 4254 reportFatal("Terminate handler called"); 4255 if(isDebuggerActive() && !g_cs->no_breaks) 4256 DOCTEST_BREAK_INTO_DEBUGGER(); 4257 std::exit(EXIT_FAILURE); // explicitly exit - otherwise the SIGABRT handler may be called as well 4258 }); 4259 4260 // SIGABRT is raised when: 4261 // - std::terminate is called FROM A DIFFERENT THREAD 4262 // - an exception is thrown from a destructor FROM A DIFFERENT THREAD 4263 // - an uncaught exception is thrown FROM A DIFFERENT THREAD 4264 prev_sigabrt_handler = std::signal(SIGABRT, [](int signal) DOCTEST_NOEXCEPT { 4265 if(signal == SIGABRT) { 4266 reportFatal("SIGABRT - Abort (abnormal termination) signal"); 4267 if(isDebuggerActive() && !g_cs->no_breaks) 4268 DOCTEST_BREAK_INTO_DEBUGGER(); 4269 std::exit(EXIT_FAILURE); 4270 } 4271 }); 4272 4273 // The following settings are taken from google test, and more 4274 // specifically from UnitTest::Run() inside of gtest.cc 4275 4276 // the user does not want to see pop-up dialogs about crashes 4277 prev_error_mode_1 = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | 4278 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); 4279 // This forces the abort message to go to stderr in all circumstances. 4280 prev_error_mode_2 = _set_error_mode(_OUT_TO_STDERR); 4281 // In the debug version, Visual Studio pops up a separate dialog 4282 // offering a choice to debug the aborted program - we want to disable that. 4283 prev_abort_behavior = _set_abort_behavior(0x0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); 4284 // In debug mode, the Windows CRT can crash with an assertion over invalid 4285 // input (e.g. passing an invalid file descriptor). The default handling 4286 // for these assertions is to pop up a dialog and wait for user input. 4287 // Instead ask the CRT to dump such assertions to stderr non-interactively. 4288 prev_report_mode = _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); 4289 prev_report_file = _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); 4290 } 4291 4292 static void reset() { 4293 if(isSet) { 4294 // Unregister handler and restore the old guarantee 4295 SetUnhandledExceptionFilter(previousTop); 4296 SetThreadStackGuarantee(&guaranteeSize); 4297 std::set_terminate(original_terminate_handler); 4298 std::signal(SIGABRT, prev_sigabrt_handler); 4299 SetErrorMode(prev_error_mode_1); 4300 _set_error_mode(prev_error_mode_2); 4301 _set_abort_behavior(prev_abort_behavior, _WRITE_ABORT_MSG | _CALL_REPORTFAULT); 4302 static_cast<void>(_CrtSetReportMode(_CRT_ASSERT, prev_report_mode)); 4303 static_cast<void>(_CrtSetReportFile(_CRT_ASSERT, prev_report_file)); 4304 isSet = false; 4305 } 4306 } 4307 4308 ~FatalConditionHandler() { reset(); } 4309 4310 private: 4311 static UINT prev_error_mode_1; 4312 static int prev_error_mode_2; 4313 static unsigned int prev_abort_behavior; 4314 static int prev_report_mode; 4315 static _HFILE prev_report_file; 4316 static void (*prev_sigabrt_handler)(int); 4317 static std::terminate_handler original_terminate_handler; 4318 static bool isSet; 4319 static ULONG guaranteeSize; 4320 static LPTOP_LEVEL_EXCEPTION_FILTER previousTop; 4321 }; 4322 4323 UINT FatalConditionHandler::prev_error_mode_1; 4324 int FatalConditionHandler::prev_error_mode_2; 4325 unsigned int FatalConditionHandler::prev_abort_behavior; 4326 int FatalConditionHandler::prev_report_mode; 4327 _HFILE FatalConditionHandler::prev_report_file; 4328 void (*FatalConditionHandler::prev_sigabrt_handler)(int); 4329 std::terminate_handler FatalConditionHandler::original_terminate_handler; 4330 bool FatalConditionHandler::isSet = false; 4331 ULONG FatalConditionHandler::guaranteeSize = 0; 4332 LPTOP_LEVEL_EXCEPTION_FILTER FatalConditionHandler::previousTop = nullptr; 4333 4334#else // DOCTEST_PLATFORM_WINDOWS 4335 4336 struct SignalDefs 4337 { 4338 int id; 4339 const char* name; 4340 }; 4341 SignalDefs signalDefs[] = {{SIGINT, "SIGINT - Terminal interrupt signal"}, 4342 {SIGILL, "SIGILL - Illegal instruction signal"}, 4343 {SIGFPE, "SIGFPE - Floating point error signal"}, 4344 {SIGSEGV, "SIGSEGV - Segmentation violation signal"}, 4345 {SIGTERM, "SIGTERM - Termination request signal"}, 4346 {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}}; 4347 4348 struct FatalConditionHandler 4349 { 4350 static bool isSet; 4351 static struct sigaction oldSigActions[DOCTEST_COUNTOF(signalDefs)]; 4352 static stack_t oldSigStack; 4353 static size_t altStackSize; 4354 static char* altStackMem; 4355 4356 static void handleSignal(int sig) { 4357 const char* name = "<unknown signal>"; 4358 for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) { 4359 SignalDefs& def = signalDefs[i]; 4360 if(sig == def.id) { 4361 name = def.name; 4362 break; 4363 } 4364 } 4365 reset(); 4366 reportFatal(name); 4367 raise(sig); 4368 } 4369 4370 static void allocateAltStackMem() { 4371 altStackMem = new char[altStackSize]; 4372 } 4373 4374 static void freeAltStackMem() { 4375 delete[] altStackMem; 4376 } 4377 4378 FatalConditionHandler() { 4379 isSet = true; 4380 stack_t sigStack; 4381 sigStack.ss_sp = altStackMem; 4382 sigStack.ss_size = altStackSize; 4383 sigStack.ss_flags = 0; 4384 sigaltstack(&sigStack, &oldSigStack); 4385 struct sigaction sa = {}; 4386 sa.sa_handler = handleSignal; // NOLINT 4387 sa.sa_flags = SA_ONSTACK; 4388 for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) { 4389 sigaction(signalDefs[i].id, &sa, &oldSigActions[i]); 4390 } 4391 } 4392 4393 ~FatalConditionHandler() { reset(); } 4394 static void reset() { 4395 if(isSet) { 4396 // Set signals back to previous values -- hopefully nobody overwrote them in the meantime 4397 for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) { 4398 sigaction(signalDefs[i].id, &oldSigActions[i], nullptr); 4399 } 4400 // Return the old stack 4401 sigaltstack(&oldSigStack, nullptr); 4402 isSet = false; 4403 } 4404 } 4405 }; 4406 4407 bool FatalConditionHandler::isSet = false; 4408 struct sigaction FatalConditionHandler::oldSigActions[DOCTEST_COUNTOF(signalDefs)] = {}; 4409 stack_t FatalConditionHandler::oldSigStack = {}; 4410 size_t FatalConditionHandler::altStackSize = 4 * SIGSTKSZ; 4411 char* FatalConditionHandler::altStackMem = nullptr; 4412 4413#endif // DOCTEST_PLATFORM_WINDOWS 4414#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH 4415 4416} // namespace 4417 4418namespace { 4419 using namespace detail; 4420 4421#ifdef DOCTEST_PLATFORM_WINDOWS 4422#define DOCTEST_OUTPUT_DEBUG_STRING(text) ::OutputDebugStringA(text) 4423#else 4424 // TODO: integration with XCode and other IDEs 4425#define DOCTEST_OUTPUT_DEBUG_STRING(text) // NOLINT(clang-diagnostic-unused-macros) 4426#endif // Platform 4427 4428 void addAssert(assertType::Enum at) { 4429 if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional 4430 g_cs->numAssertsCurrentTest_atomic++; 4431 } 4432 4433 void addFailedAssert(assertType::Enum at) { 4434 if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional 4435 g_cs->numAssertsFailedCurrentTest_atomic++; 4436 } 4437 4438#if defined(DOCTEST_CONFIG_POSIX_SIGNALS) || defined(DOCTEST_CONFIG_WINDOWS_SEH) 4439 void reportFatal(const std::string& message) { 4440 g_cs->failure_flags |= TestCaseFailureReason::Crash; 4441 4442 DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception, {message.c_str(), true}); 4443 4444 while(g_cs->subcasesStack.size()) { 4445 g_cs->subcasesStack.pop_back(); 4446 DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY); 4447 } 4448 4449 g_cs->finalizeTestCaseData(); 4450 4451 DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs); 4452 4453 DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs); 4454 } 4455#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH 4456} // namespace 4457namespace detail { 4458 4459 ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr, 4460 const char* exception_type, const char* exception_string) { 4461 m_test_case = g_cs->currentTest; 4462 m_at = at; 4463 m_file = file; 4464 m_line = line; 4465 m_expr = expr; 4466 m_failed = true; 4467 m_threw = false; 4468 m_threw_as = false; 4469 m_exception_type = exception_type; 4470 m_exception_string = exception_string; 4471#if DOCTEST_MSVC 4472 if(m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC 4473 ++m_expr; 4474#endif // MSVC 4475 } 4476 4477 void ResultBuilder::setResult(const Result& res) { 4478 m_decomp = res.m_decomp; 4479 m_failed = !res.m_passed; 4480 } 4481 4482 void ResultBuilder::translateException() { 4483 m_threw = true; 4484 m_exception = translateActiveException(); 4485 } 4486 4487 bool ResultBuilder::log() { 4488 if(m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional 4489 m_failed = !m_threw; 4490 } else if((m_at & assertType::is_throws_as) && (m_at & assertType::is_throws_with)) { //!OCLINT 4491 m_failed = !m_threw_as || (m_exception != m_exception_string); 4492 } else if(m_at & assertType::is_throws_as) { //!OCLINT bitwise operator in conditional 4493 m_failed = !m_threw_as; 4494 } else if(m_at & assertType::is_throws_with) { //!OCLINT bitwise operator in conditional 4495 m_failed = m_exception != m_exception_string; 4496 } else if(m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional 4497 m_failed = m_threw; 4498 } 4499 4500 if(m_exception.size()) 4501 m_exception = String("\"") + m_exception + "\""; 4502 4503 if(is_running_in_test) { 4504 addAssert(m_at); 4505 DOCTEST_ITERATE_THROUGH_REPORTERS(log_assert, *this); 4506 4507 if(m_failed) 4508 addFailedAssert(m_at); 4509 } else if(m_failed) { 4510 failed_out_of_a_testing_context(*this); 4511 } 4512 4513 return m_failed && isDebuggerActive() && !getContextOptions()->no_breaks && 4514 (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger 4515 } 4516 4517 void ResultBuilder::react() const { 4518 if(m_failed && checkIfShouldThrow(m_at)) 4519 throwException(); 4520 } 4521 4522 void failed_out_of_a_testing_context(const AssertData& ad) { 4523 if(g_cs->ah) 4524 g_cs->ah(ad); 4525 else 4526 std::abort(); 4527 } 4528 4529 void decomp_assert(assertType::Enum at, const char* file, int line, const char* expr, 4530 Result result) { 4531 bool failed = !result.m_passed; 4532 4533 // ################################################################################### 4534 // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT 4535 // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED 4536 // ################################################################################### 4537 DOCTEST_ASSERT_OUT_OF_TESTS(result.m_decomp); 4538 DOCTEST_ASSERT_IN_TESTS(result.m_decomp); 4539 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 4540 } 4541 4542 MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) { 4543 m_stream = getTlsOss(); 4544 m_file = file; 4545 m_line = line; 4546 m_severity = severity; 4547 } 4548 4549 IExceptionTranslator::IExceptionTranslator() = default; 4550 IExceptionTranslator::~IExceptionTranslator() = default; 4551 4552 bool MessageBuilder::log() { 4553 m_string = getTlsOssResult(); 4554 DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this); 4555 4556 const bool isWarn = m_severity & assertType::is_warn; 4557 4558 // warn is just a message in this context so we don't treat it as an assert 4559 if(!isWarn) { 4560 addAssert(m_severity); 4561 addFailedAssert(m_severity); 4562 } 4563 4564 return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn && 4565 (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger 4566 } 4567 4568 void MessageBuilder::react() { 4569 if(m_severity & assertType::is_require) //!OCLINT bitwise operator in conditional 4570 throwException(); 4571 } 4572 4573 MessageBuilder::~MessageBuilder() = default; 4574} // namespace detail 4575namespace { 4576 using namespace detail; 4577 4578 template <typename Ex> 4579 DOCTEST_NORETURN void throw_exception(Ex const& e) { 4580#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 4581 throw e; 4582#else // DOCTEST_CONFIG_NO_EXCEPTIONS 4583 std::cerr << "doctest will terminate because it needed to throw an exception.\n" 4584 << "The message was: " << e.what() << '\n'; 4585 std::terminate(); 4586#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 4587 } 4588 4589#ifndef DOCTEST_INTERNAL_ERROR 4590#define DOCTEST_INTERNAL_ERROR(msg) \ 4591 throw_exception(std::logic_error( \ 4592 __FILE__ ":" DOCTEST_TOSTR(__LINE__) ": Internal doctest error: " msg)) 4593#endif // DOCTEST_INTERNAL_ERROR 4594 4595 // clang-format off 4596 4597// ================================================================================================= 4598// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp 4599// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched. 4600// ================================================================================================= 4601 4602 class XmlEncode { 4603 public: 4604 enum ForWhat { ForTextNodes, ForAttributes }; 4605 4606 XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes ); 4607 4608 void encodeTo( std::ostream& os ) const; 4609 4610 friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ); 4611 4612 private: 4613 std::string m_str; 4614 ForWhat m_forWhat; 4615 }; 4616 4617 class XmlWriter { 4618 public: 4619 4620 class ScopedElement { 4621 public: 4622 ScopedElement( XmlWriter* writer ); 4623 4624 ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT; 4625 ScopedElement& operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT; 4626 4627 ~ScopedElement(); 4628 4629 ScopedElement& writeText( std::string const& text, bool indent = true ); 4630 4631 template<typename T> 4632 ScopedElement& writeAttribute( std::string const& name, T const& attribute ) { 4633 m_writer->writeAttribute( name, attribute ); 4634 return *this; 4635 } 4636 4637 private: 4638 mutable XmlWriter* m_writer = nullptr; 4639 }; 4640 4641 XmlWriter( std::ostream& os = std::cout ); 4642 ~XmlWriter(); 4643 4644 XmlWriter( XmlWriter const& ) = delete; 4645 XmlWriter& operator=( XmlWriter const& ) = delete; 4646 4647 XmlWriter& startElement( std::string const& name ); 4648 4649 ScopedElement scopedElement( std::string const& name ); 4650 4651 XmlWriter& endElement(); 4652 4653 XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ); 4654 4655 XmlWriter& writeAttribute( std::string const& name, const char* attribute ); 4656 4657 XmlWriter& writeAttribute( std::string const& name, bool attribute ); 4658 4659 template<typename T> 4660 XmlWriter& writeAttribute( std::string const& name, T const& attribute ) { 4661 std::stringstream rss; 4662 rss << attribute; 4663 return writeAttribute( name, rss.str() ); 4664 } 4665 4666 XmlWriter& writeText( std::string const& text, bool indent = true ); 4667 4668 //XmlWriter& writeComment( std::string const& text ); 4669 4670 //void writeStylesheetRef( std::string const& url ); 4671 4672 //XmlWriter& writeBlankLine(); 4673 4674 void ensureTagClosed(); 4675 4676 private: 4677 4678 void writeDeclaration(); 4679 4680 void newlineIfNecessary(); 4681 4682 bool m_tagIsOpen = false; 4683 bool m_needsNewline = false; 4684 std::vector<std::string> m_tags; 4685 std::string m_indent; 4686 std::ostream& m_os; 4687 }; 4688 4689// ================================================================================================= 4690// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp 4691// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched. 4692// ================================================================================================= 4693 4694using uchar = unsigned char; 4695 4696namespace { 4697 4698 size_t trailingBytes(unsigned char c) { 4699 if ((c & 0xE0) == 0xC0) { 4700 return 2; 4701 } 4702 if ((c & 0xF0) == 0xE0) { 4703 return 3; 4704 } 4705 if ((c & 0xF8) == 0xF0) { 4706 return 4; 4707 } 4708 DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered"); 4709 } 4710 4711 uint32_t headerValue(unsigned char c) { 4712 if ((c & 0xE0) == 0xC0) { 4713 return c & 0x1F; 4714 } 4715 if ((c & 0xF0) == 0xE0) { 4716 return c & 0x0F; 4717 } 4718 if ((c & 0xF8) == 0xF0) { 4719 return c & 0x07; 4720 } 4721 DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered"); 4722 } 4723 4724 void hexEscapeChar(std::ostream& os, unsigned char c) { 4725 std::ios_base::fmtflags f(os.flags()); 4726 os << "\\x" 4727 << std::uppercase << std::hex << std::setfill('0') << std::setw(2) 4728 << static_cast<int>(c); 4729 os.flags(f); 4730 } 4731 4732} // anonymous namespace 4733 4734 XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat ) 4735 : m_str( str ), 4736 m_forWhat( forWhat ) 4737 {} 4738 4739 void XmlEncode::encodeTo( std::ostream& os ) const { 4740 // Apostrophe escaping not necessary if we always use " to write attributes 4741 // (see: https://www.w3.org/TR/xml/#syntax) 4742 4743 for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) { 4744 uchar c = m_str[idx]; 4745 switch (c) { 4746 case '<': os << "<"; break; 4747 case '&': os << "&"; break; 4748 4749 case '>': 4750 // See: https://www.w3.org/TR/xml/#syntax 4751 if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']') 4752 os << ">"; 4753 else 4754 os << c; 4755 break; 4756 4757 case '\"': 4758 if (m_forWhat == ForAttributes) 4759 os << """; 4760 else 4761 os << c; 4762 break; 4763 4764 default: 4765 // Check for control characters and invalid utf-8 4766 4767 // Escape control characters in standard ascii 4768 // see https://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0 4769 if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) { 4770 hexEscapeChar(os, c); 4771 break; 4772 } 4773 4774 // Plain ASCII: Write it to stream 4775 if (c < 0x7F) { 4776 os << c; 4777 break; 4778 } 4779 4780 // UTF-8 territory 4781 // Check if the encoding is valid and if it is not, hex escape bytes. 4782 // Important: We do not check the exact decoded values for validity, only the encoding format 4783 // First check that this bytes is a valid lead byte: 4784 // This means that it is not encoded as 1111 1XXX 4785 // Or as 10XX XXXX 4786 if (c < 0xC0 || 4787 c >= 0xF8) { 4788 hexEscapeChar(os, c); 4789 break; 4790 } 4791 4792 auto encBytes = trailingBytes(c); 4793 // Are there enough bytes left to avoid accessing out-of-bounds memory? 4794 if (idx + encBytes - 1 >= m_str.size()) { 4795 hexEscapeChar(os, c); 4796 break; 4797 } 4798 // The header is valid, check data 4799 // The next encBytes bytes must together be a valid utf-8 4800 // This means: bitpattern 10XX XXXX and the extracted value is sane (ish) 4801 bool valid = true; 4802 uint32_t value = headerValue(c); 4803 for (std::size_t n = 1; n < encBytes; ++n) { 4804 uchar nc = m_str[idx + n]; 4805 valid &= ((nc & 0xC0) == 0x80); 4806 value = (value << 6) | (nc & 0x3F); 4807 } 4808 4809 if ( 4810 // Wrong bit pattern of following bytes 4811 (!valid) || 4812 // Overlong encodings 4813 (value < 0x80) || 4814 ( value < 0x800 && encBytes > 2) || // removed "0x80 <= value &&" because redundant 4815 (0x800 < value && value < 0x10000 && encBytes > 3) || 4816 // Encoded value out of range 4817 (value >= 0x110000) 4818 ) { 4819 hexEscapeChar(os, c); 4820 break; 4821 } 4822 4823 // If we got here, this is in fact a valid(ish) utf-8 sequence 4824 for (std::size_t n = 0; n < encBytes; ++n) { 4825 os << m_str[idx + n]; 4826 } 4827 idx += encBytes - 1; 4828 break; 4829 } 4830 } 4831 } 4832 4833 std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) { 4834 xmlEncode.encodeTo( os ); 4835 return os; 4836 } 4837 4838 XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer ) 4839 : m_writer( writer ) 4840 {} 4841 4842 XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT 4843 : m_writer( other.m_writer ){ 4844 other.m_writer = nullptr; 4845 } 4846 XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT { 4847 if ( m_writer ) { 4848 m_writer->endElement(); 4849 } 4850 m_writer = other.m_writer; 4851 other.m_writer = nullptr; 4852 return *this; 4853 } 4854 4855 4856 XmlWriter::ScopedElement::~ScopedElement() { 4857 if( m_writer ) 4858 m_writer->endElement(); 4859 } 4860 4861 XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) { 4862 m_writer->writeText( text, indent ); 4863 return *this; 4864 } 4865 4866 XmlWriter::XmlWriter( std::ostream& os ) : m_os( os ) 4867 { 4868 writeDeclaration(); 4869 } 4870 4871 XmlWriter::~XmlWriter() { 4872 while( !m_tags.empty() ) 4873 endElement(); 4874 } 4875 4876 XmlWriter& XmlWriter::startElement( std::string const& name ) { 4877 ensureTagClosed(); 4878 newlineIfNecessary(); 4879 m_os << m_indent << '<' << name; 4880 m_tags.push_back( name ); 4881 m_indent += " "; 4882 m_tagIsOpen = true; 4883 return *this; 4884 } 4885 4886 XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) { 4887 ScopedElement scoped( this ); 4888 startElement( name ); 4889 return scoped; 4890 } 4891 4892 XmlWriter& XmlWriter::endElement() { 4893 newlineIfNecessary(); 4894 m_indent = m_indent.substr( 0, m_indent.size()-2 ); 4895 if( m_tagIsOpen ) { 4896 m_os << "/>"; 4897 m_tagIsOpen = false; 4898 } 4899 else { 4900 m_os << m_indent << "</" << m_tags.back() << ">"; 4901 } 4902 m_os << std::endl; 4903 m_tags.pop_back(); 4904 return *this; 4905 } 4906 4907 XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) { 4908 if( !name.empty() && !attribute.empty() ) 4909 m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"'; 4910 return *this; 4911 } 4912 4913 XmlWriter& XmlWriter::writeAttribute( std::string const& name, const char* attribute ) { 4914 if( !name.empty() && attribute && attribute[0] != '\0' ) 4915 m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"'; 4916 return *this; 4917 } 4918 4919 XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) { 4920 m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"'; 4921 return *this; 4922 } 4923 4924 XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) { 4925 if( !text.empty() ){ 4926 bool tagWasOpen = m_tagIsOpen; 4927 ensureTagClosed(); 4928 if( tagWasOpen && indent ) 4929 m_os << m_indent; 4930 m_os << XmlEncode( text ); 4931 m_needsNewline = true; 4932 } 4933 return *this; 4934 } 4935 4936 //XmlWriter& XmlWriter::writeComment( std::string const& text ) { 4937 // ensureTagClosed(); 4938 // m_os << m_indent << "<!--" << text << "-->"; 4939 // m_needsNewline = true; 4940 // return *this; 4941 //} 4942 4943 //void XmlWriter::writeStylesheetRef( std::string const& url ) { 4944 // m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n"; 4945 //} 4946 4947 //XmlWriter& XmlWriter::writeBlankLine() { 4948 // ensureTagClosed(); 4949 // m_os << '\n'; 4950 // return *this; 4951 //} 4952 4953 void XmlWriter::ensureTagClosed() { 4954 if( m_tagIsOpen ) { 4955 m_os << ">" << std::endl; 4956 m_tagIsOpen = false; 4957 } 4958 } 4959 4960 void XmlWriter::writeDeclaration() { 4961 m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; 4962 } 4963 4964 void XmlWriter::newlineIfNecessary() { 4965 if( m_needsNewline ) { 4966 m_os << std::endl; 4967 m_needsNewline = false; 4968 } 4969 } 4970 4971// ================================================================================================= 4972// End of copy-pasted code from Catch 4973// ================================================================================================= 4974 4975 // clang-format on 4976 4977 struct XmlReporter : public IReporter 4978 { 4979 XmlWriter xml; 4980 std::mutex mutex; 4981 4982 // caching pointers/references to objects of these types - safe to do 4983 const ContextOptions& opt; 4984 const TestCaseData* tc = nullptr; 4985 4986 XmlReporter(const ContextOptions& co) 4987 : xml(*co.cout) 4988 , opt(co) {} 4989 4990 void log_contexts() { 4991 int num_contexts = get_num_active_contexts(); 4992 if(num_contexts) { 4993 auto contexts = get_active_contexts(); 4994 std::stringstream ss; 4995 for(int i = 0; i < num_contexts; ++i) { 4996 contexts[i]->stringify(&ss); 4997 xml.scopedElement("Info").writeText(ss.str()); 4998 ss.str(""); 4999 } 5000 } 5001 } 5002 5003 unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; } 5004 5005 void test_case_start_impl(const TestCaseData& in) { 5006 bool open_ts_tag = false; 5007 if(tc != nullptr) { // we have already opened a test suite 5008 if(std::strcmp(tc->m_test_suite, in.m_test_suite) != 0) { 5009 xml.endElement(); 5010 open_ts_tag = true; 5011 } 5012 } 5013 else { 5014 open_ts_tag = true; // first test case ==> first test suite 5015 } 5016 5017 if(open_ts_tag) { 5018 xml.startElement("TestSuite"); 5019 xml.writeAttribute("name", in.m_test_suite); 5020 } 5021 5022 tc = ∈ 5023 xml.startElement("TestCase") 5024 .writeAttribute("name", in.m_name) 5025 .writeAttribute("filename", skipPathFromFilename(in.m_file.c_str())) 5026 .writeAttribute("line", line(in.m_line)) 5027 .writeAttribute("description", in.m_description); 5028 5029 if(Approx(in.m_timeout) != 0) 5030 xml.writeAttribute("timeout", in.m_timeout); 5031 if(in.m_may_fail) 5032 xml.writeAttribute("may_fail", true); 5033 if(in.m_should_fail) 5034 xml.writeAttribute("should_fail", true); 5035 } 5036 5037 // ========================================================================================= 5038 // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE 5039 // ========================================================================================= 5040 5041 void report_query(const QueryData& in) override { 5042 test_run_start(); 5043 if(opt.list_reporters) { 5044 for(auto& curr : getListeners()) 5045 xml.scopedElement("Listener") 5046 .writeAttribute("priority", curr.first.first) 5047 .writeAttribute("name", curr.first.second); 5048 for(auto& curr : getReporters()) 5049 xml.scopedElement("Reporter") 5050 .writeAttribute("priority", curr.first.first) 5051 .writeAttribute("name", curr.first.second); 5052 } else if(opt.count || opt.list_test_cases) { 5053 for(unsigned i = 0; i < in.num_data; ++i) { 5054 xml.scopedElement("TestCase").writeAttribute("name", in.data[i]->m_name) 5055 .writeAttribute("testsuite", in.data[i]->m_test_suite) 5056 .writeAttribute("filename", skipPathFromFilename(in.data[i]->m_file.c_str())) 5057 .writeAttribute("line", line(in.data[i]->m_line)); 5058 } 5059 xml.scopedElement("OverallResultsTestCases") 5060 .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters); 5061 } else if(opt.list_test_suites) { 5062 for(unsigned i = 0; i < in.num_data; ++i) 5063 xml.scopedElement("TestSuite").writeAttribute("name", in.data[i]->m_test_suite); 5064 xml.scopedElement("OverallResultsTestCases") 5065 .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters); 5066 xml.scopedElement("OverallResultsTestSuites") 5067 .writeAttribute("unskipped", in.run_stats->numTestSuitesPassingFilters); 5068 } 5069 xml.endElement(); 5070 } 5071 5072 void test_run_start() override { 5073 // remove .exe extension - mainly to have the same output on UNIX and Windows 5074 std::string binary_name = skipPathFromFilename(opt.binary_name.c_str()); 5075#ifdef DOCTEST_PLATFORM_WINDOWS 5076 if(binary_name.rfind(".exe") != std::string::npos) 5077 binary_name = binary_name.substr(0, binary_name.length() - 4); 5078#endif // DOCTEST_PLATFORM_WINDOWS 5079 5080 xml.startElement("doctest").writeAttribute("binary", binary_name); 5081 if(opt.no_version == false) 5082 xml.writeAttribute("version", DOCTEST_VERSION_STR); 5083 5084 // only the consequential ones (TODO: filters) 5085 xml.scopedElement("Options") 5086 .writeAttribute("order_by", opt.order_by.c_str()) 5087 .writeAttribute("rand_seed", opt.rand_seed) 5088 .writeAttribute("first", opt.first) 5089 .writeAttribute("last", opt.last) 5090 .writeAttribute("abort_after", opt.abort_after) 5091 .writeAttribute("subcase_filter_levels", opt.subcase_filter_levels) 5092 .writeAttribute("case_sensitive", opt.case_sensitive) 5093 .writeAttribute("no_throw", opt.no_throw) 5094 .writeAttribute("no_skip", opt.no_skip); 5095 } 5096 5097 void test_run_end(const TestRunStats& p) override { 5098 if(tc) // the TestSuite tag - only if there has been at least 1 test case 5099 xml.endElement(); 5100 5101 xml.scopedElement("OverallResultsAsserts") 5102 .writeAttribute("successes", p.numAsserts - p.numAssertsFailed) 5103 .writeAttribute("failures", p.numAssertsFailed); 5104 5105 xml.startElement("OverallResultsTestCases") 5106 .writeAttribute("successes", 5107 p.numTestCasesPassingFilters - p.numTestCasesFailed) 5108 .writeAttribute("failures", p.numTestCasesFailed); 5109 if(opt.no_skipped_summary == false) 5110 xml.writeAttribute("skipped", p.numTestCases - p.numTestCasesPassingFilters); 5111 xml.endElement(); 5112 5113 xml.endElement(); 5114 } 5115 5116 void test_case_start(const TestCaseData& in) override { 5117 test_case_start_impl(in); 5118 xml.ensureTagClosed(); 5119 } 5120 5121 void test_case_reenter(const TestCaseData&) override {} 5122 5123 void test_case_end(const CurrentTestCaseStats& st) override { 5124 xml.startElement("OverallResultsAsserts") 5125 .writeAttribute("successes", 5126 st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest) 5127 .writeAttribute("failures", st.numAssertsFailedCurrentTest); 5128 if(opt.duration) 5129 xml.writeAttribute("duration", st.seconds); 5130 if(tc->m_expected_failures) 5131 xml.writeAttribute("expected_failures", tc->m_expected_failures); 5132 xml.endElement(); 5133 5134 xml.endElement(); 5135 } 5136 5137 void test_case_exception(const TestCaseException& e) override { 5138 std::lock_guard<std::mutex> lock(mutex); 5139 5140 xml.scopedElement("Exception") 5141 .writeAttribute("crash", e.is_crash) 5142 .writeText(e.error_string.c_str()); 5143 } 5144 5145 void subcase_start(const SubcaseSignature& in) override { 5146 std::lock_guard<std::mutex> lock(mutex); 5147 5148 xml.startElement("SubCase") 5149 .writeAttribute("name", in.m_name) 5150 .writeAttribute("filename", skipPathFromFilename(in.m_file)) 5151 .writeAttribute("line", line(in.m_line)); 5152 xml.ensureTagClosed(); 5153 } 5154 5155 void subcase_end() override { xml.endElement(); } 5156 5157 void log_assert(const AssertData& rb) override { 5158 if(!rb.m_failed && !opt.success) 5159 return; 5160 5161 std::lock_guard<std::mutex> lock(mutex); 5162 5163 xml.startElement("Expression") 5164 .writeAttribute("success", !rb.m_failed) 5165 .writeAttribute("type", assertString(rb.m_at)) 5166 .writeAttribute("filename", skipPathFromFilename(rb.m_file)) 5167 .writeAttribute("line", line(rb.m_line)); 5168 5169 xml.scopedElement("Original").writeText(rb.m_expr); 5170 5171 if(rb.m_threw) 5172 xml.scopedElement("Exception").writeText(rb.m_exception.c_str()); 5173 5174 if(rb.m_at & assertType::is_throws_as) 5175 xml.scopedElement("ExpectedException").writeText(rb.m_exception_type); 5176 if(rb.m_at & assertType::is_throws_with) 5177 xml.scopedElement("ExpectedExceptionString").writeText(rb.m_exception_string); 5178 if((rb.m_at & assertType::is_normal) && !rb.m_threw) 5179 xml.scopedElement("Expanded").writeText(rb.m_decomp.c_str()); 5180 5181 log_contexts(); 5182 5183 xml.endElement(); 5184 } 5185 5186 void log_message(const MessageData& mb) override { 5187 std::lock_guard<std::mutex> lock(mutex); 5188 5189 xml.startElement("Message") 5190 .writeAttribute("type", failureString(mb.m_severity)) 5191 .writeAttribute("filename", skipPathFromFilename(mb.m_file)) 5192 .writeAttribute("line", line(mb.m_line)); 5193 5194 xml.scopedElement("Text").writeText(mb.m_string.c_str()); 5195 5196 log_contexts(); 5197 5198 xml.endElement(); 5199 } 5200 5201 void test_case_skipped(const TestCaseData& in) override { 5202 if(opt.no_skipped_summary == false) { 5203 test_case_start_impl(in); 5204 xml.writeAttribute("skipped", "true"); 5205 xml.endElement(); 5206 } 5207 } 5208 }; 5209 5210 DOCTEST_REGISTER_REPORTER("xml", 0, XmlReporter); 5211 5212 void fulltext_log_assert_to_stream(std::ostream& s, const AssertData& rb) { 5213 if((rb.m_at & (assertType::is_throws_as | assertType::is_throws_with)) == 5214 0) //!OCLINT bitwise operator in conditional 5215 s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << " ) " 5216 << Color::None; 5217 5218 if(rb.m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional 5219 s << (rb.m_threw ? "threw as expected!" : "did NOT throw at all!") << "\n"; 5220 } else if((rb.m_at & assertType::is_throws_as) && 5221 (rb.m_at & assertType::is_throws_with)) { //!OCLINT 5222 s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \"" 5223 << rb.m_exception_string << "\", " << rb.m_exception_type << " ) " << Color::None; 5224 if(rb.m_threw) { 5225 if(!rb.m_failed) { 5226 s << "threw as expected!\n"; 5227 } else { 5228 s << "threw a DIFFERENT exception! (contents: " << rb.m_exception << ")\n"; 5229 } 5230 } else { 5231 s << "did NOT throw at all!\n"; 5232 } 5233 } else if(rb.m_at & 5234 assertType::is_throws_as) { //!OCLINT bitwise operator in conditional 5235 s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", " 5236 << rb.m_exception_type << " ) " << Color::None 5237 << (rb.m_threw ? (rb.m_threw_as ? "threw as expected!" : 5238 "threw a DIFFERENT exception: ") : 5239 "did NOT throw at all!") 5240 << Color::Cyan << rb.m_exception << "\n"; 5241 } else if(rb.m_at & 5242 assertType::is_throws_with) { //!OCLINT bitwise operator in conditional 5243 s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \"" 5244 << rb.m_exception_string << "\" ) " << Color::None 5245 << (rb.m_threw ? (!rb.m_failed ? "threw as expected!" : 5246 "threw a DIFFERENT exception: ") : 5247 "did NOT throw at all!") 5248 << Color::Cyan << rb.m_exception << "\n"; 5249 } else if(rb.m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional 5250 s << (rb.m_threw ? "THREW exception: " : "didn't throw!") << Color::Cyan 5251 << rb.m_exception << "\n"; 5252 } else { 5253 s << (rb.m_threw ? "THREW exception: " : 5254 (!rb.m_failed ? "is correct!\n" : "is NOT correct!\n")); 5255 if(rb.m_threw) 5256 s << rb.m_exception << "\n"; 5257 else 5258 s << " values: " << assertString(rb.m_at) << "( " << rb.m_decomp << " )\n"; 5259 } 5260 } 5261 5262 // TODO: 5263 // - log_message() 5264 // - respond to queries 5265 // - honor remaining options 5266 // - more attributes in tags 5267 struct JUnitReporter : public IReporter 5268 { 5269 XmlWriter xml; 5270 std::mutex mutex; 5271 Timer timer; 5272 std::vector<String> deepestSubcaseStackNames; 5273 5274 struct JUnitTestCaseData 5275 { 5276 static std::string getCurrentTimestamp() { 5277 // Beware, this is not reentrant because of backward compatibility issues 5278 // Also, UTC only, again because of backward compatibility (%z is C++11) 5279 time_t rawtime; 5280 std::time(&rawtime); 5281 auto const timeStampSize = sizeof("2017-01-16T17:06:45Z"); 5282 5283 std::tm timeInfo; 5284#ifdef DOCTEST_PLATFORM_WINDOWS 5285 gmtime_s(&timeInfo, &rawtime); 5286#else // DOCTEST_PLATFORM_WINDOWS 5287 gmtime_r(&rawtime, &timeInfo); 5288#endif // DOCTEST_PLATFORM_WINDOWS 5289 5290 char timeStamp[timeStampSize]; 5291 const char* const fmt = "%Y-%m-%dT%H:%M:%SZ"; 5292 5293 std::strftime(timeStamp, timeStampSize, fmt, &timeInfo); 5294 return std::string(timeStamp); 5295 } 5296 5297 struct JUnitTestMessage 5298 { 5299 JUnitTestMessage(const std::string& _message, const std::string& _type, const std::string& _details) 5300 : message(_message), type(_type), details(_details) {} 5301 5302 JUnitTestMessage(const std::string& _message, const std::string& _details) 5303 : message(_message), type(), details(_details) {} 5304 5305 std::string message, type, details; 5306 }; 5307 5308 struct JUnitTestCase 5309 { 5310 JUnitTestCase(const std::string& _classname, const std::string& _name) 5311 : classname(_classname), name(_name), time(0), failures() {} 5312 5313 std::string classname, name; 5314 double time; 5315 std::vector<JUnitTestMessage> failures, errors; 5316 }; 5317 5318 void add(const std::string& classname, const std::string& name) { 5319 testcases.emplace_back(classname, name); 5320 } 5321 5322 void appendSubcaseNamesToLastTestcase(std::vector<String> nameStack) { 5323 for(auto& curr: nameStack) 5324 if(curr.size()) 5325 testcases.back().name += std::string("/") + curr.c_str(); 5326 } 5327 5328 void addTime(double time) { 5329 if(time < 1e-4) 5330 time = 0; 5331 testcases.back().time = time; 5332 totalSeconds += time; 5333 } 5334 5335 void addFailure(const std::string& message, const std::string& type, const std::string& details) { 5336 testcases.back().failures.emplace_back(message, type, details); 5337 ++totalFailures; 5338 } 5339 5340 void addError(const std::string& message, const std::string& details) { 5341 testcases.back().errors.emplace_back(message, details); 5342 ++totalErrors; 5343 } 5344 5345 std::vector<JUnitTestCase> testcases; 5346 double totalSeconds = 0; 5347 int totalErrors = 0, totalFailures = 0; 5348 }; 5349 5350 JUnitTestCaseData testCaseData; 5351 5352 // caching pointers/references to objects of these types - safe to do 5353 const ContextOptions& opt; 5354 const TestCaseData* tc = nullptr; 5355 5356 JUnitReporter(const ContextOptions& co) 5357 : xml(*co.cout) 5358 , opt(co) {} 5359 5360 unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; } 5361 5362 // ========================================================================================= 5363 // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE 5364 // ========================================================================================= 5365 5366 void report_query(const QueryData&) override {} 5367 5368 void test_run_start() override {} 5369 5370 void test_run_end(const TestRunStats& p) override { 5371 // remove .exe extension - mainly to have the same output on UNIX and Windows 5372 std::string binary_name = skipPathFromFilename(opt.binary_name.c_str()); 5373#ifdef DOCTEST_PLATFORM_WINDOWS 5374 if(binary_name.rfind(".exe") != std::string::npos) 5375 binary_name = binary_name.substr(0, binary_name.length() - 4); 5376#endif // DOCTEST_PLATFORM_WINDOWS 5377 xml.startElement("testsuites"); 5378 xml.startElement("testsuite").writeAttribute("name", binary_name) 5379 .writeAttribute("errors", testCaseData.totalErrors) 5380 .writeAttribute("failures", testCaseData.totalFailures) 5381 .writeAttribute("tests", p.numAsserts); 5382 if(opt.no_time_in_output == false) { 5383 xml.writeAttribute("time", testCaseData.totalSeconds); 5384 xml.writeAttribute("timestamp", JUnitTestCaseData::getCurrentTimestamp()); 5385 } 5386 if(opt.no_version == false) 5387 xml.writeAttribute("doctest_version", DOCTEST_VERSION_STR); 5388 5389 for(const auto& testCase : testCaseData.testcases) { 5390 xml.startElement("testcase") 5391 .writeAttribute("classname", testCase.classname) 5392 .writeAttribute("name", testCase.name); 5393 if(opt.no_time_in_output == false) 5394 xml.writeAttribute("time", testCase.time); 5395 // This is not ideal, but it should be enough to mimic gtest's junit output. 5396 xml.writeAttribute("status", "run"); 5397 5398 for(const auto& failure : testCase.failures) { 5399 xml.scopedElement("failure") 5400 .writeAttribute("message", failure.message) 5401 .writeAttribute("type", failure.type) 5402 .writeText(failure.details, false); 5403 } 5404 5405 for(const auto& error : testCase.errors) { 5406 xml.scopedElement("error") 5407 .writeAttribute("message", error.message) 5408 .writeText(error.details); 5409 } 5410 5411 xml.endElement(); 5412 } 5413 xml.endElement(); 5414 xml.endElement(); 5415 } 5416 5417 void test_case_start(const TestCaseData& in) override { 5418 testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name); 5419 timer.start(); 5420 } 5421 5422 void test_case_reenter(const TestCaseData& in) override { 5423 testCaseData.addTime(timer.getElapsedSeconds()); 5424 testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames); 5425 deepestSubcaseStackNames.clear(); 5426 5427 timer.start(); 5428 testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name); 5429 } 5430 5431 void test_case_end(const CurrentTestCaseStats&) override { 5432 testCaseData.addTime(timer.getElapsedSeconds()); 5433 testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames); 5434 deepestSubcaseStackNames.clear(); 5435 } 5436 5437 void test_case_exception(const TestCaseException& e) override { 5438 std::lock_guard<std::mutex> lock(mutex); 5439 testCaseData.addError("exception", e.error_string.c_str()); 5440 } 5441 5442 void subcase_start(const SubcaseSignature& in) override { 5443 std::lock_guard<std::mutex> lock(mutex); 5444 deepestSubcaseStackNames.push_back(in.m_name); 5445 } 5446 5447 void subcase_end() override {} 5448 5449 void log_assert(const AssertData& rb) override { 5450 if(!rb.m_failed) // report only failures & ignore the `success` option 5451 return; 5452 5453 std::lock_guard<std::mutex> lock(mutex); 5454 5455 std::ostringstream os; 5456 os << skipPathFromFilename(rb.m_file) << (opt.gnu_file_line ? ":" : "(") 5457 << line(rb.m_line) << (opt.gnu_file_line ? ":" : "):") << std::endl; 5458 5459 fulltext_log_assert_to_stream(os, rb); 5460 log_contexts(os); 5461 testCaseData.addFailure(rb.m_decomp.c_str(), assertString(rb.m_at), os.str()); 5462 } 5463 5464 void log_message(const MessageData&) override {} 5465 5466 void test_case_skipped(const TestCaseData&) override {} 5467 5468 void log_contexts(std::ostringstream& s) { 5469 int num_contexts = get_num_active_contexts(); 5470 if(num_contexts) { 5471 auto contexts = get_active_contexts(); 5472 5473 s << " logged: "; 5474 for(int i = 0; i < num_contexts; ++i) { 5475 s << (i == 0 ? "" : " "); 5476 contexts[i]->stringify(&s); 5477 s << std::endl; 5478 } 5479 } 5480 } 5481 }; 5482 5483 DOCTEST_REGISTER_REPORTER("junit", 0, JUnitReporter); 5484 5485 struct Whitespace 5486 { 5487 int nrSpaces; 5488 explicit Whitespace(int nr) 5489 : nrSpaces(nr) {} 5490 }; 5491 5492 std::ostream& operator<<(std::ostream& out, const Whitespace& ws) { 5493 if(ws.nrSpaces != 0) 5494 out << std::setw(ws.nrSpaces) << ' '; 5495 return out; 5496 } 5497 5498 struct ConsoleReporter : public IReporter 5499 { 5500 std::ostream& s; 5501 bool hasLoggedCurrentTestStart; 5502 std::vector<SubcaseSignature> subcasesStack; 5503 size_t currentSubcaseLevel; 5504 std::mutex mutex; 5505 5506 // caching pointers/references to objects of these types - safe to do 5507 const ContextOptions& opt; 5508 const TestCaseData* tc; 5509 5510 ConsoleReporter(const ContextOptions& co) 5511 : s(*co.cout) 5512 , opt(co) {} 5513 5514 ConsoleReporter(const ContextOptions& co, std::ostream& ostr) 5515 : s(ostr) 5516 , opt(co) {} 5517 5518 // ========================================================================================= 5519 // WHAT FOLLOWS ARE HELPERS USED BY THE OVERRIDES OF THE VIRTUAL METHODS OF THE INTERFACE 5520 // ========================================================================================= 5521 5522 void separator_to_stream() { 5523 s << Color::Yellow 5524 << "===============================================================================" 5525 "\n"; 5526 } 5527 5528 const char* getSuccessOrFailString(bool success, assertType::Enum at, 5529 const char* success_str) { 5530 if(success) 5531 return success_str; 5532 return failureString(at); 5533 } 5534 5535 Color::Enum getSuccessOrFailColor(bool success, assertType::Enum at) { 5536 return success ? Color::BrightGreen : 5537 (at & assertType::is_warn) ? Color::Yellow : Color::Red; 5538 } 5539 5540 void successOrFailColoredStringToStream(bool success, assertType::Enum at, 5541 const char* success_str = "SUCCESS") { 5542 s << getSuccessOrFailColor(success, at) 5543 << getSuccessOrFailString(success, at, success_str) << ": "; 5544 } 5545 5546 void log_contexts() { 5547 int num_contexts = get_num_active_contexts(); 5548 if(num_contexts) { 5549 auto contexts = get_active_contexts(); 5550 5551 s << Color::None << " logged: "; 5552 for(int i = 0; i < num_contexts; ++i) { 5553 s << (i == 0 ? "" : " "); 5554 contexts[i]->stringify(&s); 5555 s << "\n"; 5556 } 5557 } 5558 5559 s << "\n"; 5560 } 5561 5562 // this was requested to be made virtual so users could override it 5563 virtual void file_line_to_stream(const char* file, int line, 5564 const char* tail = "") { 5565 s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(") 5566 << (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option 5567 << (opt.gnu_file_line ? ":" : "):") << tail; 5568 } 5569 5570 void logTestStart() { 5571 if(hasLoggedCurrentTestStart) 5572 return; 5573 5574 separator_to_stream(); 5575 file_line_to_stream(tc->m_file.c_str(), tc->m_line, "\n"); 5576 if(tc->m_description) 5577 s << Color::Yellow << "DESCRIPTION: " << Color::None << tc->m_description << "\n"; 5578 if(tc->m_test_suite && tc->m_test_suite[0] != '\0') 5579 s << Color::Yellow << "TEST SUITE: " << Color::None << tc->m_test_suite << "\n"; 5580 if(strncmp(tc->m_name, " Scenario:", 11) != 0) 5581 s << Color::Yellow << "TEST CASE: "; 5582 s << Color::None << tc->m_name << "\n"; 5583 5584 for(size_t i = 0; i < currentSubcaseLevel; ++i) { 5585 if(subcasesStack[i].m_name[0] != '\0') 5586 s << " " << subcasesStack[i].m_name << "\n"; 5587 } 5588 5589 if(currentSubcaseLevel != subcasesStack.size()) { 5590 s << Color::Yellow << "\nDEEPEST SUBCASE STACK REACHED (DIFFERENT FROM THE CURRENT ONE):\n" << Color::None; 5591 for(size_t i = 0; i < subcasesStack.size(); ++i) { 5592 if(subcasesStack[i].m_name[0] != '\0') 5593 s << " " << subcasesStack[i].m_name << "\n"; 5594 } 5595 } 5596 5597 s << "\n"; 5598 5599 hasLoggedCurrentTestStart = true; 5600 } 5601 5602 void printVersion() { 5603 if(opt.no_version == false) 5604 s << Color::Cyan << "[doctest] " << Color::None << "doctest version is \"" 5605 << DOCTEST_VERSION_STR << "\"\n"; 5606 } 5607 5608 void printIntro() { 5609 printVersion(); 5610 s << Color::Cyan << "[doctest] " << Color::None 5611 << "run with \"--" DOCTEST_OPTIONS_PREFIX_DISPLAY "help\" for options\n"; 5612 } 5613 5614 void printHelp() { 5615 int sizePrefixDisplay = static_cast<int>(strlen(DOCTEST_OPTIONS_PREFIX_DISPLAY)); 5616 printVersion(); 5617 // clang-format off 5618 s << Color::Cyan << "[doctest]\n" << Color::None; 5619 s << Color::Cyan << "[doctest] " << Color::None; 5620 s << "boolean values: \"1/on/yes/true\" or \"0/off/no/false\"\n"; 5621 s << Color::Cyan << "[doctest] " << Color::None; 5622 s << "filter values: \"str1,str2,str3\" (comma separated strings)\n"; 5623 s << Color::Cyan << "[doctest]\n" << Color::None; 5624 s << Color::Cyan << "[doctest] " << Color::None; 5625 s << "filters use wildcards for matching strings\n"; 5626 s << Color::Cyan << "[doctest] " << Color::None; 5627 s << "something passes a filter if any of the strings in a filter matches\n"; 5628#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS 5629 s << Color::Cyan << "[doctest]\n" << Color::None; 5630 s << Color::Cyan << "[doctest] " << Color::None; 5631 s << "ALL FLAGS, OPTIONS AND FILTERS ALSO AVAILABLE WITH A \"" DOCTEST_CONFIG_OPTIONS_PREFIX "\" PREFIX!!!\n"; 5632#endif 5633 s << Color::Cyan << "[doctest]\n" << Color::None; 5634 s << Color::Cyan << "[doctest] " << Color::None; 5635 s << "Query flags - the program quits after them. Available:\n\n"; 5636 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "?, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "help, -" DOCTEST_OPTIONS_PREFIX_DISPLAY "h " 5637 << Whitespace(sizePrefixDisplay*0) << "prints this message\n"; 5638 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "v, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "version " 5639 << Whitespace(sizePrefixDisplay*1) << "prints the version\n"; 5640 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "c, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "count " 5641 << Whitespace(sizePrefixDisplay*1) << "prints the number of matching tests\n"; 5642 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ltc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-cases " 5643 << Whitespace(sizePrefixDisplay*1) << "lists all matching tests by name\n"; 5644 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lts, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-suites " 5645 << Whitespace(sizePrefixDisplay*1) << "lists all matching test suites\n"; 5646 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lr, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-reporters " 5647 << Whitespace(sizePrefixDisplay*1) << "lists all registered reporters\n\n"; 5648 // ================================================================================== << 79 5649 s << Color::Cyan << "[doctest] " << Color::None; 5650 s << "The available <int>/<string> options/filters are:\n\n"; 5651 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case=<filters> " 5652 << Whitespace(sizePrefixDisplay*1) << "filters tests by their name\n"; 5653 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case-exclude=<filters> " 5654 << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their name\n"; 5655 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sf, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file=<filters> " 5656 << Whitespace(sizePrefixDisplay*1) << "filters tests by their file\n"; 5657 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sfe, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file-exclude=<filters> " 5658 << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their file\n"; 5659 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ts, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite=<filters> " 5660 << Whitespace(sizePrefixDisplay*1) << "filters tests by their test suite\n"; 5661 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tse, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite-exclude=<filters> " 5662 << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their test suite\n"; 5663 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase=<filters> " 5664 << Whitespace(sizePrefixDisplay*1) << "filters subcases by their name\n"; 5665 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-exclude=<filters> " 5666 << Whitespace(sizePrefixDisplay*1) << "filters OUT subcases by their name\n"; 5667 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "r, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "reporters=<filters> " 5668 << Whitespace(sizePrefixDisplay*1) << "reporters to use (console is default)\n"; 5669 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "o, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "out=<string> " 5670 << Whitespace(sizePrefixDisplay*1) << "output filename\n"; 5671 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ob, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "order-by=<string> " 5672 << Whitespace(sizePrefixDisplay*1) << "how the tests should be ordered\n"; 5673 s << Whitespace(sizePrefixDisplay*3) << " <string> - [file/suite/name/rand/none]\n"; 5674 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "rs, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "rand-seed=<int> " 5675 << Whitespace(sizePrefixDisplay*1) << "seed for random ordering\n"; 5676 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "f, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "first=<int> " 5677 << Whitespace(sizePrefixDisplay*1) << "the first test passing the filters to\n"; 5678 s << Whitespace(sizePrefixDisplay*3) << " execute - for range-based execution\n"; 5679 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "l, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "last=<int> " 5680 << Whitespace(sizePrefixDisplay*1) << "the last test passing the filters to\n"; 5681 s << Whitespace(sizePrefixDisplay*3) << " execute - for range-based execution\n"; 5682 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "aa, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "abort-after=<int> " 5683 << Whitespace(sizePrefixDisplay*1) << "stop after <int> failed assertions\n"; 5684 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "scfl,--" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-filter-levels=<int> " 5685 << Whitespace(sizePrefixDisplay*1) << "apply filters for the first <int> levels\n"; 5686 s << Color::Cyan << "\n[doctest] " << Color::None; 5687 s << "Bool options - can be used like flags and true is assumed. Available:\n\n"; 5688 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "s, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "success=<bool> " 5689 << Whitespace(sizePrefixDisplay*1) << "include successful assertions in output\n"; 5690 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "cs, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "case-sensitive=<bool> " 5691 << Whitespace(sizePrefixDisplay*1) << "filters being treated as case sensitive\n"; 5692 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "e, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "exit=<bool> " 5693 << Whitespace(sizePrefixDisplay*1) << "exits after the tests finish\n"; 5694 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "d, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "duration=<bool> " 5695 << Whitespace(sizePrefixDisplay*1) << "prints the time duration of each test\n"; 5696 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nt, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-throw=<bool> " 5697 << Whitespace(sizePrefixDisplay*1) << "skips exceptions-related assert checks\n"; 5698 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ne, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-exitcode=<bool> " 5699 << Whitespace(sizePrefixDisplay*1) << "returns (or exits) always with success\n"; 5700 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nr, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-run=<bool> " 5701 << Whitespace(sizePrefixDisplay*1) << "skips all runtime doctest operations\n"; 5702 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nv, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-version=<bool> " 5703 << Whitespace(sizePrefixDisplay*1) << "omit the framework version in the output\n"; 5704 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-colors=<bool> " 5705 << Whitespace(sizePrefixDisplay*1) << "disables colors in output\n"; 5706 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "fc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "force-colors=<bool> " 5707 << Whitespace(sizePrefixDisplay*1) << "use colors even when not in a tty\n"; 5708 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nb, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-breaks=<bool> " 5709 << Whitespace(sizePrefixDisplay*1) << "disables breakpoints in debuggers\n"; 5710 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ns, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-skip=<bool> " 5711 << Whitespace(sizePrefixDisplay*1) << "don't skip test cases marked as skip\n"; 5712 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "gfl, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "gnu-file-line=<bool> " 5713 << Whitespace(sizePrefixDisplay*1) << ":n: vs (n): for line numbers in output\n"; 5714 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "npf, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-path-filenames=<bool> " 5715 << Whitespace(sizePrefixDisplay*1) << "only filenames and no paths in output\n"; 5716 s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nln, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-line-numbers=<bool> " 5717 << Whitespace(sizePrefixDisplay*1) << "0 instead of real line numbers in output\n"; 5718 // ================================================================================== << 79 5719 // clang-format on 5720 5721 s << Color::Cyan << "\n[doctest] " << Color::None; 5722 s << "for more information visit the project documentation\n\n"; 5723 } 5724 5725 void printRegisteredReporters() { 5726 printVersion(); 5727 auto printReporters = [this] (const reporterMap& reporters, const char* type) { 5728 if(reporters.size()) { 5729 s << Color::Cyan << "[doctest] " << Color::None << "listing all registered " << type << "\n"; 5730 for(auto& curr : reporters) 5731 s << "priority: " << std::setw(5) << curr.first.first 5732 << " name: " << curr.first.second << "\n"; 5733 } 5734 }; 5735 printReporters(getListeners(), "listeners"); 5736 printReporters(getReporters(), "reporters"); 5737 } 5738 5739 void list_query_results() { 5740 separator_to_stream(); 5741 if(opt.count || opt.list_test_cases) { 5742 s << Color::Cyan << "[doctest] " << Color::None 5743 << "unskipped test cases passing the current filters: " 5744 << g_cs->numTestCasesPassingFilters << "\n"; 5745 } else if(opt.list_test_suites) { 5746 s << Color::Cyan << "[doctest] " << Color::None 5747 << "unskipped test cases passing the current filters: " 5748 << g_cs->numTestCasesPassingFilters << "\n"; 5749 s << Color::Cyan << "[doctest] " << Color::None 5750 << "test suites with unskipped test cases passing the current filters: " 5751 << g_cs->numTestSuitesPassingFilters << "\n"; 5752 } 5753 } 5754 5755 // ========================================================================================= 5756 // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE 5757 // ========================================================================================= 5758 5759 void report_query(const QueryData& in) override { 5760 if(opt.version) { 5761 printVersion(); 5762 } else if(opt.help) { 5763 printHelp(); 5764 } else if(opt.list_reporters) { 5765 printRegisteredReporters(); 5766 } else if(opt.count || opt.list_test_cases) { 5767 if(opt.list_test_cases) { 5768 s << Color::Cyan << "[doctest] " << Color::None 5769 << "listing all test case names\n"; 5770 separator_to_stream(); 5771 } 5772 5773 for(unsigned i = 0; i < in.num_data; ++i) 5774 s << Color::None << in.data[i]->m_name << "\n"; 5775 5776 separator_to_stream(); 5777 5778 s << Color::Cyan << "[doctest] " << Color::None 5779 << "unskipped test cases passing the current filters: " 5780 << g_cs->numTestCasesPassingFilters << "\n"; 5781 5782 } else if(opt.list_test_suites) { 5783 s << Color::Cyan << "[doctest] " << Color::None << "listing all test suites\n"; 5784 separator_to_stream(); 5785 5786 for(unsigned i = 0; i < in.num_data; ++i) 5787 s << Color::None << in.data[i]->m_test_suite << "\n"; 5788 5789 separator_to_stream(); 5790 5791 s << Color::Cyan << "[doctest] " << Color::None 5792 << "unskipped test cases passing the current filters: " 5793 << g_cs->numTestCasesPassingFilters << "\n"; 5794 s << Color::Cyan << "[doctest] " << Color::None 5795 << "test suites with unskipped test cases passing the current filters: " 5796 << g_cs->numTestSuitesPassingFilters << "\n"; 5797 } 5798 } 5799 5800 void test_run_start() override { printIntro(); } 5801 5802 void test_run_end(const TestRunStats& p) override { 5803 separator_to_stream(); 5804 s << std::dec; 5805 5806 auto totwidth = int(std::ceil(log10((std::max(p.numTestCasesPassingFilters, static_cast<unsigned>(p.numAsserts))) + 1))); 5807 auto passwidth = int(std::ceil(log10((std::max(p.numTestCasesPassingFilters - p.numTestCasesFailed, static_cast<unsigned>(p.numAsserts - p.numAssertsFailed))) + 1))); 5808 auto failwidth = int(std::ceil(log10((std::max(p.numTestCasesFailed, static_cast<unsigned>(p.numAssertsFailed))) + 1))); 5809 const bool anythingFailed = p.numTestCasesFailed > 0 || p.numAssertsFailed > 0; 5810 s << Color::Cyan << "[doctest] " << Color::None << "test cases: " << std::setw(totwidth) 5811 << p.numTestCasesPassingFilters << " | " 5812 << ((p.numTestCasesPassingFilters == 0 || anythingFailed) ? Color::None : 5813 Color::Green) 5814 << std::setw(passwidth) << p.numTestCasesPassingFilters - p.numTestCasesFailed << " passed" 5815 << Color::None << " | " << (p.numTestCasesFailed > 0 ? Color::Red : Color::None) 5816 << std::setw(failwidth) << p.numTestCasesFailed << " failed" << Color::None << " |"; 5817 if(opt.no_skipped_summary == false) { 5818 const int numSkipped = p.numTestCases - p.numTestCasesPassingFilters; 5819 s << " " << (numSkipped == 0 ? Color::None : Color::Yellow) << numSkipped 5820 << " skipped" << Color::None; 5821 } 5822 s << "\n"; 5823 s << Color::Cyan << "[doctest] " << Color::None << "assertions: " << std::setw(totwidth) 5824 << p.numAsserts << " | " 5825 << ((p.numAsserts == 0 || anythingFailed) ? Color::None : Color::Green) 5826 << std::setw(passwidth) << (p.numAsserts - p.numAssertsFailed) << " passed" << Color::None 5827 << " | " << (p.numAssertsFailed > 0 ? Color::Red : Color::None) << std::setw(failwidth) 5828 << p.numAssertsFailed << " failed" << Color::None << " |\n"; 5829 s << Color::Cyan << "[doctest] " << Color::None 5830 << "Status: " << (p.numTestCasesFailed > 0 ? Color::Red : Color::Green) 5831 << ((p.numTestCasesFailed > 0) ? "FAILURE!" : "SUCCESS!") << Color::None << std::endl; 5832 } 5833 5834 void test_case_start(const TestCaseData& in) override { 5835 hasLoggedCurrentTestStart = false; 5836 tc = ∈ 5837 subcasesStack.clear(); 5838 currentSubcaseLevel = 0; 5839 } 5840 5841 void test_case_reenter(const TestCaseData&) override { 5842 subcasesStack.clear(); 5843 } 5844 5845 void test_case_end(const CurrentTestCaseStats& st) override { 5846 if(tc->m_no_output) 5847 return; 5848 5849 // log the preamble of the test case only if there is something 5850 // else to print - something other than that an assert has failed 5851 if(opt.duration || 5852 (st.failure_flags && st.failure_flags != TestCaseFailureReason::AssertFailure)) 5853 logTestStart(); 5854 5855 if(opt.duration) 5856 s << Color::None << std::setprecision(6) << std::fixed << st.seconds 5857 << " s: " << tc->m_name << "\n"; 5858 5859 if(st.failure_flags & TestCaseFailureReason::Timeout) 5860 s << Color::Red << "Test case exceeded time limit of " << std::setprecision(6) 5861 << std::fixed << tc->m_timeout << "!\n"; 5862 5863 if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedButDidnt) { 5864 s << Color::Red << "Should have failed but didn't! Marking it as failed!\n"; 5865 } else if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedAndDid) { 5866 s << Color::Yellow << "Failed as expected so marking it as not failed\n"; 5867 } else if(st.failure_flags & TestCaseFailureReason::CouldHaveFailedAndDid) { 5868 s << Color::Yellow << "Allowed to fail so marking it as not failed\n"; 5869 } else if(st.failure_flags & TestCaseFailureReason::DidntFailExactlyNumTimes) { 5870 s << Color::Red << "Didn't fail exactly " << tc->m_expected_failures 5871 << " times so marking it as failed!\n"; 5872 } else if(st.failure_flags & TestCaseFailureReason::FailedExactlyNumTimes) { 5873 s << Color::Yellow << "Failed exactly " << tc->m_expected_failures 5874 << " times as expected so marking it as not failed!\n"; 5875 } 5876 if(st.failure_flags & TestCaseFailureReason::TooManyFailedAsserts) { 5877 s << Color::Red << "Aborting - too many failed asserts!\n"; 5878 } 5879 s << Color::None; // lgtm [cpp/useless-expression] 5880 } 5881 5882 void test_case_exception(const TestCaseException& e) override { 5883 if(tc->m_no_output) 5884 return; 5885 5886 logTestStart(); 5887 5888 file_line_to_stream(tc->m_file.c_str(), tc->m_line, " "); 5889 successOrFailColoredStringToStream(false, e.is_crash ? assertType::is_require : 5890 assertType::is_check); 5891 s << Color::Red << (e.is_crash ? "test case CRASHED: " : "test case THREW exception: ") 5892 << Color::Cyan << e.error_string << "\n"; 5893 5894 int num_stringified_contexts = get_num_stringified_contexts(); 5895 if(num_stringified_contexts) { 5896 auto stringified_contexts = get_stringified_contexts(); 5897 s << Color::None << " logged: "; 5898 for(int i = num_stringified_contexts; i > 0; --i) { 5899 s << (i == num_stringified_contexts ? "" : " ") 5900 << stringified_contexts[i - 1] << "\n"; 5901 } 5902 } 5903 s << "\n" << Color::None; 5904 } 5905 5906 void subcase_start(const SubcaseSignature& subc) override { 5907 std::lock_guard<std::mutex> lock(mutex); 5908 subcasesStack.push_back(subc); 5909 ++currentSubcaseLevel; 5910 hasLoggedCurrentTestStart = false; 5911 } 5912 5913 void subcase_end() override { 5914 std::lock_guard<std::mutex> lock(mutex); 5915 --currentSubcaseLevel; 5916 hasLoggedCurrentTestStart = false; 5917 } 5918 5919 void log_assert(const AssertData& rb) override { 5920 if((!rb.m_failed && !opt.success) || tc->m_no_output) 5921 return; 5922 5923 std::lock_guard<std::mutex> lock(mutex); 5924 5925 logTestStart(); 5926 5927 file_line_to_stream(rb.m_file, rb.m_line, " "); 5928 successOrFailColoredStringToStream(!rb.m_failed, rb.m_at); 5929 5930 fulltext_log_assert_to_stream(s, rb); 5931 5932 log_contexts(); 5933 } 5934 5935 void log_message(const MessageData& mb) override { 5936 if(tc->m_no_output) 5937 return; 5938 5939 std::lock_guard<std::mutex> lock(mutex); 5940 5941 logTestStart(); 5942 5943 file_line_to_stream(mb.m_file, mb.m_line, " "); 5944 s << getSuccessOrFailColor(false, mb.m_severity) 5945 << getSuccessOrFailString(mb.m_severity & assertType::is_warn, mb.m_severity, 5946 "MESSAGE") << ": "; 5947 s << Color::None << mb.m_string << "\n"; 5948 log_contexts(); 5949 } 5950 5951 void test_case_skipped(const TestCaseData&) override {} 5952 }; 5953 5954 DOCTEST_REGISTER_REPORTER("console", 0, ConsoleReporter); 5955 5956#ifdef DOCTEST_PLATFORM_WINDOWS 5957 struct DebugOutputWindowReporter : public ConsoleReporter 5958 { 5959 DOCTEST_THREAD_LOCAL static std::ostringstream oss; 5960 5961 DebugOutputWindowReporter(const ContextOptions& co) 5962 : ConsoleReporter(co, oss) {} 5963 5964#define DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(func, type, arg) \ 5965 void func(type arg) override { \ 5966 bool with_col = g_no_colors; \ 5967 g_no_colors = false; \ 5968 ConsoleReporter::func(arg); \ 5969 if(oss.tellp() != std::streampos{}) { \ 5970 DOCTEST_OUTPUT_DEBUG_STRING(oss.str().c_str()); \ 5971 oss.str(""); \ 5972 } \ 5973 g_no_colors = with_col; \ 5974 } 5975 5976 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_start, DOCTEST_EMPTY, DOCTEST_EMPTY) 5977 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_end, const TestRunStats&, in) 5978 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_start, const TestCaseData&, in) 5979 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_reenter, const TestCaseData&, in) 5980 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_end, const CurrentTestCaseStats&, in) 5981 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_exception, const TestCaseException&, in) 5982 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_start, const SubcaseSignature&, in) 5983 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_end, DOCTEST_EMPTY, DOCTEST_EMPTY) 5984 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_assert, const AssertData&, in) 5985 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_message, const MessageData&, in) 5986 DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_skipped, const TestCaseData&, in) 5987 }; 5988 5989 DOCTEST_THREAD_LOCAL std::ostringstream DebugOutputWindowReporter::oss; 5990#endif // DOCTEST_PLATFORM_WINDOWS 5991 5992 // the implementation of parseOption() 5993 bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) { 5994 // going from the end to the beginning and stopping on the first occurrence from the end 5995 for(int i = argc; i > 0; --i) { 5996 auto index = i - 1; 5997 auto temp = std::strstr(argv[index], pattern); 5998 if(temp && (value || strlen(temp) == strlen(pattern))) { //!OCLINT prefer early exits and continue 5999 // eliminate matches in which the chars before the option are not '-' 6000 bool noBadCharsFound = true; 6001 auto curr = argv[index]; 6002 while(curr != temp) { 6003 if(*curr++ != '-') { 6004 noBadCharsFound = false; 6005 break; 6006 } 6007 } 6008 if(noBadCharsFound && argv[index][0] == '-') { 6009 if(value) { 6010 // parsing the value of an option 6011 temp += strlen(pattern); 6012 const unsigned len = strlen(temp); 6013 if(len) { 6014 *value = temp; 6015 return true; 6016 } 6017 } else { 6018 // just a flag - no value 6019 return true; 6020 } 6021 } 6022 } 6023 } 6024 return false; 6025 } 6026 6027 // parses an option and returns the string after the '=' character 6028 bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr, 6029 const String& defaultVal = String()) { 6030 if(value) 6031 *value = defaultVal; 6032#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS 6033 // offset (normally 3 for "dt-") to skip prefix 6034 if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value)) 6035 return true; 6036#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS 6037 return parseOptionImpl(argc, argv, pattern, value); 6038 } 6039 6040 // locates a flag on the command line 6041 bool parseFlag(int argc, const char* const* argv, const char* pattern) { 6042 return parseOption(argc, argv, pattern); 6043 } 6044 6045 // parses a comma separated list of words after a pattern in one of the arguments in argv 6046 bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern, 6047 std::vector<String>& res) { 6048 String filtersString; 6049 if(parseOption(argc, argv, pattern, &filtersString)) { 6050 // tokenize with "," as a separator 6051 // cppcheck-suppress strtokCalled 6052 DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations") 6053 auto pch = std::strtok(filtersString.c_str(), ","); // modifies the string 6054 while(pch != nullptr) { 6055 if(strlen(pch)) 6056 res.push_back(pch); 6057 // uses the strtok() internal state to go to the next token 6058 // cppcheck-suppress strtokCalled 6059 pch = std::strtok(nullptr, ","); 6060 } 6061 DOCTEST_CLANG_SUPPRESS_WARNING_POP 6062 return true; 6063 } 6064 return false; 6065 } 6066 6067 enum optionType 6068 { 6069 option_bool, 6070 option_int 6071 }; 6072 6073 // parses an int/bool option from the command line 6074 bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type, 6075 int& res) { 6076 String parsedValue; 6077 if(!parseOption(argc, argv, pattern, &parsedValue)) 6078 return false; 6079 6080 if(type == 0) { 6081 // boolean 6082 const char positive[][5] = {"1", "true", "on", "yes"}; // 5 - strlen("true") + 1 6083 const char negative[][6] = {"0", "false", "off", "no"}; // 6 - strlen("false") + 1 6084 6085 // if the value matches any of the positive/negative possibilities 6086 for(unsigned i = 0; i < 4; i++) { 6087 if(parsedValue.compare(positive[i], true) == 0) { 6088 res = 1; //!OCLINT parameter reassignment 6089 return true; 6090 } 6091 if(parsedValue.compare(negative[i], true) == 0) { 6092 res = 0; //!OCLINT parameter reassignment 6093 return true; 6094 } 6095 } 6096 } else { 6097 // integer 6098 // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse... 6099 int theInt = std::atoi(parsedValue.c_str()); // NOLINT 6100 if(theInt != 0) { 6101 res = theInt; //!OCLINT parameter reassignment 6102 return true; 6103 } 6104 } 6105 return false; 6106 } 6107} // namespace 6108 6109Context::Context(int argc, const char* const* argv) 6110 : p(new detail::ContextState) { 6111 parseArgs(argc, argv, true); 6112 if(argc) 6113 p->binary_name = argv[0]; 6114} 6115 6116Context::~Context() { 6117 if(g_cs == p) 6118 g_cs = nullptr; 6119 delete p; 6120} 6121 6122void Context::applyCommandLine(int argc, const char* const* argv) { 6123 parseArgs(argc, argv); 6124 if(argc) 6125 p->binary_name = argv[0]; 6126} 6127 6128// parses args 6129void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) { 6130 using namespace detail; 6131 6132 // clang-format off 6133 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file=", p->filters[0]); 6134 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sf=", p->filters[0]); 6135 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file-exclude=",p->filters[1]); 6136 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sfe=", p->filters[1]); 6137 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite=", p->filters[2]); 6138 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ts=", p->filters[2]); 6139 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite-exclude=", p->filters[3]); 6140 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tse=", p->filters[3]); 6141 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case=", p->filters[4]); 6142 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tc=", p->filters[4]); 6143 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case-exclude=", p->filters[5]); 6144 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tce=", p->filters[5]); 6145 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase=", p->filters[6]); 6146 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sc=", p->filters[6]); 6147 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase-exclude=", p->filters[7]); 6148 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sce=", p->filters[7]); 6149 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "reporters=", p->filters[8]); 6150 parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "r=", p->filters[8]); 6151 // clang-format on 6152 6153 int intRes = 0; 6154 String strRes; 6155 6156#define DOCTEST_PARSE_AS_BOOL_OR_FLAG(name, sname, var, default) \ 6157 if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_bool, intRes) || \ 6158 parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_bool, intRes)) \ 6159 p->var = static_cast<bool>(intRes); \ 6160 else if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name) || \ 6161 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname)) \ 6162 p->var = true; \ 6163 else if(withDefaults) \ 6164 p->var = default 6165 6166#define DOCTEST_PARSE_INT_OPTION(name, sname, var, default) \ 6167 if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_int, intRes) || \ 6168 parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_int, intRes)) \ 6169 p->var = intRes; \ 6170 else if(withDefaults) \ 6171 p->var = default 6172 6173#define DOCTEST_PARSE_STR_OPTION(name, sname, var, default) \ 6174 if(parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", &strRes, default) || \ 6175 parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", &strRes, default) || \ 6176 withDefaults) \ 6177 p->var = strRes 6178 6179 // clang-format off 6180 DOCTEST_PARSE_STR_OPTION("out", "o", out, ""); 6181 DOCTEST_PARSE_STR_OPTION("order-by", "ob", order_by, "file"); 6182 DOCTEST_PARSE_INT_OPTION("rand-seed", "rs", rand_seed, 0); 6183 6184 DOCTEST_PARSE_INT_OPTION("first", "f", first, 0); 6185 DOCTEST_PARSE_INT_OPTION("last", "l", last, UINT_MAX); 6186 6187 DOCTEST_PARSE_INT_OPTION("abort-after", "aa", abort_after, 0); 6188 DOCTEST_PARSE_INT_OPTION("subcase-filter-levels", "scfl", subcase_filter_levels, INT_MAX); 6189 6190 DOCTEST_PARSE_AS_BOOL_OR_FLAG("success", "s", success, false); 6191 DOCTEST_PARSE_AS_BOOL_OR_FLAG("case-sensitive", "cs", case_sensitive, false); 6192 DOCTEST_PARSE_AS_BOOL_OR_FLAG("exit", "e", exit, false); 6193 DOCTEST_PARSE_AS_BOOL_OR_FLAG("duration", "d", duration, false); 6194 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-throw", "nt", no_throw, false); 6195 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-exitcode", "ne", no_exitcode, false); 6196 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-run", "nr", no_run, false); 6197 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-version", "nv", no_version, false); 6198 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-colors", "nc", no_colors, false); 6199 DOCTEST_PARSE_AS_BOOL_OR_FLAG("force-colors", "fc", force_colors, false); 6200 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-breaks", "nb", no_breaks, false); 6201 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skip", "ns", no_skip, false); 6202 DOCTEST_PARSE_AS_BOOL_OR_FLAG("gnu-file-line", "gfl", gnu_file_line, !bool(DOCTEST_MSVC)); 6203 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-path-filenames", "npf", no_path_in_filenames, false); 6204 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-line-numbers", "nln", no_line_numbers, false); 6205 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-debug-output", "ndo", no_debug_output, false); 6206 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skipped-summary", "nss", no_skipped_summary, false); 6207 DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-time-in-output", "ntio", no_time_in_output, false); 6208 // clang-format on 6209 6210 if(withDefaults) { 6211 p->help = false; 6212 p->version = false; 6213 p->count = false; 6214 p->list_test_cases = false; 6215 p->list_test_suites = false; 6216 p->list_reporters = false; 6217 } 6218 if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "help") || 6219 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "h") || 6220 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "?")) { 6221 p->help = true; 6222 p->exit = true; 6223 } 6224 if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "version") || 6225 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "v")) { 6226 p->version = true; 6227 p->exit = true; 6228 } 6229 if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "count") || 6230 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "c")) { 6231 p->count = true; 6232 p->exit = true; 6233 } 6234 if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-cases") || 6235 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ltc")) { 6236 p->list_test_cases = true; 6237 p->exit = true; 6238 } 6239 if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-suites") || 6240 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lts")) { 6241 p->list_test_suites = true; 6242 p->exit = true; 6243 } 6244 if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-reporters") || 6245 parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lr")) { 6246 p->list_reporters = true; 6247 p->exit = true; 6248 } 6249} 6250 6251// allows the user to add procedurally to the filters from the command line 6252void Context::addFilter(const char* filter, const char* value) { setOption(filter, value); } 6253 6254// allows the user to clear all filters from the command line 6255void Context::clearFilters() { 6256 for(auto& curr : p->filters) 6257 curr.clear(); 6258} 6259 6260// allows the user to override procedurally the int/bool options from the command line 6261void Context::setOption(const char* option, int value) { 6262 setOption(option, toString(value).c_str()); 6263 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) 6264} 6265 6266// allows the user to override procedurally the string options from the command line 6267void Context::setOption(const char* option, const char* value) { 6268 auto argv = String("-") + option + "=" + value; 6269 auto lvalue = argv.c_str(); 6270 parseArgs(1, &lvalue); 6271} 6272 6273// users should query this in their main() and exit the program if true 6274bool Context::shouldExit() { return p->exit; } 6275 6276void Context::setAsDefaultForAssertsOutOfTestCases() { g_cs = p; } 6277 6278void Context::setAssertHandler(detail::assert_handler ah) { p->ah = ah; } 6279 6280// the main function that does all the filtering and test running 6281int Context::run() { 6282 using namespace detail; 6283 6284 // save the old context state in case such was setup - for using asserts out of a testing context 6285 auto old_cs = g_cs; 6286 // this is the current contest 6287 g_cs = p; 6288 is_running_in_test = true; 6289 6290 g_no_colors = p->no_colors; 6291 p->resetRunData(); 6292 6293 // stdout by default 6294 p->cout = &std::cout; 6295 p->cerr = &std::cerr; 6296 6297 // or to a file if specified 6298 std::fstream fstr; 6299 if(p->out.size()) { 6300 fstr.open(p->out.c_str(), std::fstream::out); 6301 p->cout = &fstr; 6302 } 6303 6304 FatalConditionHandler::allocateAltStackMem(); 6305 6306 auto cleanup_and_return = [&]() { 6307 FatalConditionHandler::freeAltStackMem(); 6308 6309 if(fstr.is_open()) 6310 fstr.close(); 6311 6312 // restore context 6313 g_cs = old_cs; 6314 is_running_in_test = false; 6315 6316 // we have to free the reporters which were allocated when the run started 6317 for(auto& curr : p->reporters_currently_used) 6318 delete curr; 6319 p->reporters_currently_used.clear(); 6320 6321 if(p->numTestCasesFailed && !p->no_exitcode) 6322 return EXIT_FAILURE; 6323 return EXIT_SUCCESS; 6324 }; 6325 6326 // setup default reporter if none is given through the command line 6327 if(p->filters[8].empty()) 6328 p->filters[8].push_back("console"); 6329 6330 // check to see if any of the registered reporters has been selected 6331 for(auto& curr : getReporters()) { 6332 if(matchesAny(curr.first.second.c_str(), p->filters[8], false, p->case_sensitive)) 6333 p->reporters_currently_used.push_back(curr.second(*g_cs)); 6334 } 6335 6336 // TODO: check if there is nothing in reporters_currently_used 6337 6338 // prepend all listeners 6339 for(auto& curr : getListeners()) 6340 p->reporters_currently_used.insert(p->reporters_currently_used.begin(), curr.second(*g_cs)); 6341 6342#ifdef DOCTEST_PLATFORM_WINDOWS 6343 if(isDebuggerActive() && p->no_debug_output == false) 6344 p->reporters_currently_used.push_back(new DebugOutputWindowReporter(*g_cs)); 6345#endif // DOCTEST_PLATFORM_WINDOWS 6346 6347 // handle version, help and no_run 6348 if(p->no_run || p->version || p->help || p->list_reporters) { 6349 DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, QueryData()); 6350 6351 return cleanup_and_return(); 6352 } 6353 6354 std::vector<const TestCase*> testArray; 6355 for(auto& curr : getRegisteredTests()) 6356 testArray.push_back(&curr); 6357 p->numTestCases = testArray.size(); 6358 6359 // sort the collected records 6360 if(!testArray.empty()) { 6361 if(p->order_by.compare("file", true) == 0) { 6362 std::sort(testArray.begin(), testArray.end(), fileOrderComparator); 6363 } else if(p->order_by.compare("suite", true) == 0) { 6364 std::sort(testArray.begin(), testArray.end(), suiteOrderComparator); 6365 } else if(p->order_by.compare("name", true) == 0) { 6366 std::sort(testArray.begin(), testArray.end(), nameOrderComparator); 6367 } else if(p->order_by.compare("rand", true) == 0) { 6368 std::srand(p->rand_seed); 6369 6370 // random_shuffle implementation 6371 const auto first = &testArray[0]; 6372 for(size_t i = testArray.size() - 1; i > 0; --i) { 6373 int idxToSwap = std::rand() % (i + 1); // NOLINT 6374 6375 const auto temp = first[i]; 6376 6377 first[i] = first[idxToSwap]; 6378 first[idxToSwap] = temp; 6379 } 6380 } else if(p->order_by.compare("none", true) == 0) { 6381 // means no sorting - beneficial for death tests which call into the executable 6382 // with a specific test case in mind - we don't want to slow down the startup times 6383 } 6384 } 6385 6386 std::set<String> testSuitesPassingFilt; 6387 6388 bool query_mode = p->count || p->list_test_cases || p->list_test_suites; 6389 std::vector<const TestCaseData*> queryResults; 6390 6391 if(!query_mode) 6392 DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_start, DOCTEST_EMPTY); 6393 6394 // invoke the registered functions if they match the filter criteria (or just count them) 6395 for(auto& curr : testArray) { 6396 const auto& tc = *curr; 6397 6398 bool skip_me = false; 6399 if(tc.m_skip && !p->no_skip) 6400 skip_me = true; 6401 6402 if(!matchesAny(tc.m_file.c_str(), p->filters[0], true, p->case_sensitive)) 6403 skip_me = true; 6404 if(matchesAny(tc.m_file.c_str(), p->filters[1], false, p->case_sensitive)) 6405 skip_me = true; 6406 if(!matchesAny(tc.m_test_suite, p->filters[2], true, p->case_sensitive)) 6407 skip_me = true; 6408 if(matchesAny(tc.m_test_suite, p->filters[3], false, p->case_sensitive)) 6409 skip_me = true; 6410 if(!matchesAny(tc.m_name, p->filters[4], true, p->case_sensitive)) 6411 skip_me = true; 6412 if(matchesAny(tc.m_name, p->filters[5], false, p->case_sensitive)) 6413 skip_me = true; 6414 6415 if(!skip_me) 6416 p->numTestCasesPassingFilters++; 6417 6418 // skip the test if it is not in the execution range 6419 if((p->last < p->numTestCasesPassingFilters && p->first <= p->last) || 6420 (p->first > p->numTestCasesPassingFilters)) 6421 skip_me = true; 6422 6423 if(skip_me) { 6424 if(!query_mode) 6425 DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_skipped, tc); 6426 continue; 6427 } 6428 6429 // do not execute the test if we are to only count the number of filter passing tests 6430 if(p->count) 6431 continue; 6432 6433 // print the name of the test and don't execute it 6434 if(p->list_test_cases) { 6435 queryResults.push_back(&tc); 6436 continue; 6437 } 6438 6439 // print the name of the test suite if not done already and don't execute it 6440 if(p->list_test_suites) { 6441 if((testSuitesPassingFilt.count(tc.m_test_suite) == 0) && tc.m_test_suite[0] != '\0') { 6442 queryResults.push_back(&tc); 6443 testSuitesPassingFilt.insert(tc.m_test_suite); 6444 p->numTestSuitesPassingFilters++; 6445 } 6446 continue; 6447 } 6448 6449 // execute the test if it passes all the filtering 6450 { 6451 p->currentTest = &tc; 6452 6453 p->failure_flags = TestCaseFailureReason::None; 6454 p->seconds = 0; 6455 6456 // reset atomic counters 6457 p->numAssertsFailedCurrentTest_atomic = 0; 6458 p->numAssertsCurrentTest_atomic = 0; 6459 6460 p->subcasesPassed.clear(); 6461 6462 DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_start, tc); 6463 6464 p->timer.start(); 6465 6466 bool run_test = true; 6467 6468 do { 6469 // reset some of the fields for subcases (except for the set of fully passed ones) 6470 p->should_reenter = false; 6471 p->subcasesCurrentMaxLevel = 0; 6472 p->subcasesStack.clear(); 6473 6474 p->shouldLogCurrentException = true; 6475 6476 // reset stuff for logging with INFO() 6477 p->stringifiedContexts.clear(); 6478 6479#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 6480 try { 6481#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 6482// MSVC 2015 diagnoses fatalConditionHandler as unused (because reset() is a static method) 6483DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4101) // unreferenced local variable 6484 FatalConditionHandler fatalConditionHandler; // Handle signals 6485 // execute the test 6486 tc.m_test(); 6487 fatalConditionHandler.reset(); 6488DOCTEST_MSVC_SUPPRESS_WARNING_POP 6489#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS 6490 } catch(const TestFailureException&) { 6491 p->failure_flags |= TestCaseFailureReason::AssertFailure; 6492 } catch(...) { 6493 DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception, 6494 {translateActiveException(), false}); 6495 p->failure_flags |= TestCaseFailureReason::Exception; 6496 } 6497#endif // DOCTEST_CONFIG_NO_EXCEPTIONS 6498 6499 // exit this loop if enough assertions have failed - even if there are more subcases 6500 if(p->abort_after > 0 && 6501 p->numAssertsFailed + p->numAssertsFailedCurrentTest_atomic >= p->abort_after) { 6502 run_test = false; 6503 p->failure_flags |= TestCaseFailureReason::TooManyFailedAsserts; 6504 } 6505 6506 if(p->should_reenter && run_test) 6507 DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_reenter, tc); 6508 if(!p->should_reenter) 6509 run_test = false; 6510 } while(run_test); 6511 6512 p->finalizeTestCaseData(); 6513 6514 DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs); 6515 6516 p->currentTest = nullptr; 6517 6518 // stop executing tests if enough assertions have failed 6519 if(p->abort_after > 0 && p->numAssertsFailed >= p->abort_after) 6520 break; 6521 } 6522 } 6523 6524 if(!query_mode) { 6525 DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs); 6526 } else { 6527 QueryData qdata; 6528 qdata.run_stats = g_cs; 6529 qdata.data = queryResults.data(); 6530 qdata.num_data = unsigned(queryResults.size()); 6531 DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, qdata); 6532 } 6533 6534 // see these issues on the reasoning for this: 6535 // - https://github.com/onqtam/doctest/issues/143#issuecomment-414418903 6536 // - https://github.com/onqtam/doctest/issues/126 6537 auto DOCTEST_FIX_FOR_MACOS_LIBCPP_IOSFWD_STRING_LINK_ERRORS = []() DOCTEST_NOINLINE 6538 { std::cout << std::string(); }; 6539 DOCTEST_FIX_FOR_MACOS_LIBCPP_IOSFWD_STRING_LINK_ERRORS(); 6540 6541 return cleanup_and_return(); 6542} 6543 6544IReporter::~IReporter() = default; 6545 6546int IReporter::get_num_active_contexts() { return detail::g_infoContexts.size(); } 6547const IContextScope* const* IReporter::get_active_contexts() { 6548 return get_num_active_contexts() ? &detail::g_infoContexts[0] : nullptr; 6549} 6550 6551int IReporter::get_num_stringified_contexts() { return detail::g_cs->stringifiedContexts.size(); } 6552const String* IReporter::get_stringified_contexts() { 6553 return get_num_stringified_contexts() ? &detail::g_cs->stringifiedContexts[0] : nullptr; 6554} 6555 6556namespace detail { 6557 void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) { 6558 if(isReporter) 6559 getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c)); 6560 else 6561 getListeners().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c)); 6562 } 6563} // namespace detail 6564 6565} // namespace doctest 6566 6567#endif // DOCTEST_CONFIG_DISABLE 6568 6569#ifdef DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 6570DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4007) // 'function' : must be 'attribute' - see issue #182 6571int main(int argc, char** argv) { return doctest::Context(argc, argv).run(); } 6572DOCTEST_MSVC_SUPPRESS_WARNING_POP 6573#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN 6574 6575DOCTEST_CLANG_SUPPRESS_WARNING_POP 6576DOCTEST_MSVC_SUPPRESS_WARNING_POP 6577DOCTEST_GCC_SUPPRESS_WARNING_POP 6578 6579#endif // DOCTEST_LIBRARY_IMPLEMENTATION 6580#endif // DOCTEST_CONFIG_IMPLEMENT 6581