CoCalc -- doctest.h

GitHub Repository: Roblox/luau
Path: blob/master/extern/doctest.h
²⁷²³ views
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/doctest/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 9
52

53
// util we need here
54
#define DOCTEST_TOSTR_IMPL(x) #x
55
#define DOCTEST_TOSTR(x) DOCTEST_TOSTR_IMPL(x)
56

57
#define DOCTEST_VERSION_STR                                                                        \
58
    DOCTEST_TOSTR(DOCTEST_VERSION_MAJOR) "."                                                       \
59
    DOCTEST_TOSTR(DOCTEST_VERSION_MINOR) "."                                                       \
60
    DOCTEST_TOSTR(DOCTEST_VERSION_PATCH)
61

62
#define DOCTEST_VERSION                                                                            \
63
    (DOCTEST_VERSION_MAJOR * 10000 + DOCTEST_VERSION_MINOR * 100 + DOCTEST_VERSION_PATCH)
64

65
// =================================================================================================
66
// == COMPILER VERSION =============================================================================
67
// =================================================================================================
68

69
// ideas for the version stuff are taken from here: https://github.com/cxxstuff/cxx_detect
70

71
#ifdef _MSC_VER
72
#define DOCTEST_CPLUSPLUS _MSVC_LANG
73
#else
74
#define DOCTEST_CPLUSPLUS __cplusplus
75
#endif
76

77
#define DOCTEST_COMPILER(MAJOR, MINOR, PATCH) ((MAJOR)*10000000 + (MINOR)*100000 + (PATCH))
78

79
// GCC/Clang and GCC/MSVC are mutually exclusive, but Clang/MSVC are not because of clang-cl...
80
#if defined(_MSC_VER) && defined(_MSC_FULL_VER)
81
#if _MSC_VER == _MSC_FULL_VER / 10000
82
#define DOCTEST_MSVC DOCTEST_COMPILER(_MSC_VER / 100, _MSC_VER % 100, _MSC_FULL_VER % 10000)
83
#else // MSVC
84
#define DOCTEST_MSVC                                                                               \
85
    DOCTEST_COMPILER(_MSC_VER / 100, (_MSC_FULL_VER / 100000) % 100, _MSC_FULL_VER % 100000)
86
#endif // MSVC
87
#endif // MSVC
88
#if defined(__clang__) && defined(__clang_minor__)
89
#define DOCTEST_CLANG DOCTEST_COMPILER(__clang_major__, __clang_minor__, __clang_patchlevel__)
90
#elif defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) &&              \
91
        !defined(__INTEL_COMPILER)
92
#define DOCTEST_GCC DOCTEST_COMPILER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
93
#endif // GCC
94

95
#ifndef DOCTEST_MSVC
96
#define DOCTEST_MSVC 0
97
#endif // DOCTEST_MSVC
98
#ifndef DOCTEST_CLANG
99
#define DOCTEST_CLANG 0
100
#endif // DOCTEST_CLANG
101
#ifndef DOCTEST_GCC
102
#define DOCTEST_GCC 0
103
#endif // DOCTEST_GCC
104

105
// =================================================================================================
106
// == COMPILER WARNINGS HELPERS ====================================================================
107
// =================================================================================================
108

109
#if DOCTEST_CLANG
110
#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
111
#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH _Pragma("clang diagnostic push")
112
#define DOCTEST_CLANG_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(clang diagnostic ignored w)
113
#define DOCTEST_CLANG_SUPPRESS_WARNING_POP _Pragma("clang diagnostic pop")
114
#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w)                                                \
115
    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH DOCTEST_CLANG_SUPPRESS_WARNING(w)
116
#else // DOCTEST_CLANG
117
#define DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
118
#define DOCTEST_CLANG_SUPPRESS_WARNING(w)
119
#define DOCTEST_CLANG_SUPPRESS_WARNING_POP
120
#define DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH(w)
121
#endif // DOCTEST_CLANG
122

123
#if DOCTEST_GCC
124
#define DOCTEST_PRAGMA_TO_STR(x) _Pragma(#x)
125
#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH _Pragma("GCC diagnostic push")
126
#define DOCTEST_GCC_SUPPRESS_WARNING(w) DOCTEST_PRAGMA_TO_STR(GCC diagnostic ignored w)
127
#define DOCTEST_GCC_SUPPRESS_WARNING_POP _Pragma("GCC diagnostic pop")
128
#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w)                                                  \
129
    DOCTEST_GCC_SUPPRESS_WARNING_PUSH DOCTEST_GCC_SUPPRESS_WARNING(w)
130
#else // DOCTEST_GCC
131
#define DOCTEST_GCC_SUPPRESS_WARNING_PUSH
132
#define DOCTEST_GCC_SUPPRESS_WARNING(w)
133
#define DOCTEST_GCC_SUPPRESS_WARNING_POP
134
#define DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH(w)
135
#endif // DOCTEST_GCC
136

137
#if DOCTEST_MSVC
138
#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH __pragma(warning(push))
139
#define DOCTEST_MSVC_SUPPRESS_WARNING(w) __pragma(warning(disable : w))
140
#define DOCTEST_MSVC_SUPPRESS_WARNING_POP __pragma(warning(pop))
141
#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w)                                                 \
142
    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH DOCTEST_MSVC_SUPPRESS_WARNING(w)
143
#else // DOCTEST_MSVC
144
#define DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
145
#define DOCTEST_MSVC_SUPPRESS_WARNING(w)
146
#define DOCTEST_MSVC_SUPPRESS_WARNING_POP
147
#define DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(w)
148
#endif // DOCTEST_MSVC
149

150
// =================================================================================================
151
// == COMPILER WARNINGS ============================================================================
152
// =================================================================================================
153

154
// both the header and the implementation suppress all of these,
155
// so it only makes sense to aggregrate them like so
156
#define DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH                                                      \
157
    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH                                                            \
158
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wunknown-pragmas")                                            \
159
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wweak-vtables")                                               \
160
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wpadded")                                                     \
161
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-prototypes")                                         \
162
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat")                                               \
163
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")                                      \
164
                                                                                                   \
165
    DOCTEST_GCC_SUPPRESS_WARNING_PUSH                                                              \
166
    DOCTEST_GCC_SUPPRESS_WARNING("-Wunknown-pragmas")                                              \
167
    DOCTEST_GCC_SUPPRESS_WARNING("-Wpragmas")                                                      \
168
    DOCTEST_GCC_SUPPRESS_WARNING("-Weffc++")                                                       \
169
    DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-overflow")                                              \
170
    DOCTEST_GCC_SUPPRESS_WARNING("-Wstrict-aliasing")                                              \
171
    DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-declarations")                                         \
172
    DOCTEST_GCC_SUPPRESS_WARNING("-Wuseless-cast")                                                 \
173
    DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept")                                                     \
174
                                                                                                   \
175
    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH                                                             \
176
    /* these 4 also disabled globally via cmake: */                                                \
177
    DOCTEST_MSVC_SUPPRESS_WARNING(4514) /* unreferenced inline function has been removed */        \
178
    DOCTEST_MSVC_SUPPRESS_WARNING(4571) /* SEH related */                                          \
179
    DOCTEST_MSVC_SUPPRESS_WARNING(4710) /* function not inlined */                                 \
180
    DOCTEST_MSVC_SUPPRESS_WARNING(4711) /* function selected for inline expansion*/                \
181
    /* */                                                                                          \
182
    DOCTEST_MSVC_SUPPRESS_WARNING(4616) /* invalid compiler warning */                             \
183
    DOCTEST_MSVC_SUPPRESS_WARNING(4619) /* invalid compiler warning */                             \
184
    DOCTEST_MSVC_SUPPRESS_WARNING(4996) /* The compiler encountered a deprecated declaration */    \
185
    DOCTEST_MSVC_SUPPRESS_WARNING(4706) /* assignment within conditional expression */             \
186
    DOCTEST_MSVC_SUPPRESS_WARNING(4512) /* 'class' : assignment operator could not be generated */ \
187
    DOCTEST_MSVC_SUPPRESS_WARNING(4127) /* conditional expression is constant */                   \
188
    DOCTEST_MSVC_SUPPRESS_WARNING(4820) /* padding */                                              \
189
    DOCTEST_MSVC_SUPPRESS_WARNING(4625) /* copy constructor was implicitly deleted */              \
190
    DOCTEST_MSVC_SUPPRESS_WARNING(4626) /* assignment operator was implicitly deleted */           \
191
    DOCTEST_MSVC_SUPPRESS_WARNING(5027) /* move assignment operator implicitly deleted */          \
192
    DOCTEST_MSVC_SUPPRESS_WARNING(5026) /* move constructor was implicitly deleted */              \
193
    DOCTEST_MSVC_SUPPRESS_WARNING(4640) /* construction of local static object not thread-safe */  \
194
    DOCTEST_MSVC_SUPPRESS_WARNING(5045) /* Spectre mitigation for memory load */                   \
195
    /* static analysis */                                                                          \
196
    DOCTEST_MSVC_SUPPRESS_WARNING(26439) /* Function may not throw. Declare it 'noexcept' */       \
197
    DOCTEST_MSVC_SUPPRESS_WARNING(26495) /* Always initialize a member variable */                 \
198
    DOCTEST_MSVC_SUPPRESS_WARNING(26451) /* Arithmetic overflow ... */                             \
199
    DOCTEST_MSVC_SUPPRESS_WARNING(26444) /* Avoid unnamed objects with custom ctor and dtor... */  \
200
    DOCTEST_MSVC_SUPPRESS_WARNING(26812) /* Prefer 'enum class' over 'enum' */
201

202
#define DOCTEST_SUPPRESS_COMMON_WARNINGS_POP                                                       \
203
    DOCTEST_CLANG_SUPPRESS_WARNING_POP                                                             \
204
    DOCTEST_GCC_SUPPRESS_WARNING_POP                                                               \
205
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
206

207
DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH
208

209
DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
210
DOCTEST_CLANG_SUPPRESS_WARNING("-Wnon-virtual-dtor")
211
DOCTEST_CLANG_SUPPRESS_WARNING("-Wdeprecated")
212

213
DOCTEST_GCC_SUPPRESS_WARNING_PUSH
214
DOCTEST_GCC_SUPPRESS_WARNING("-Wctor-dtor-privacy")
215
DOCTEST_GCC_SUPPRESS_WARNING("-Wnon-virtual-dtor")
216
DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-promo")
217

218
DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
219
DOCTEST_MSVC_SUPPRESS_WARNING(4623) // default constructor was implicitly defined as deleted
220

221
#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN                                 \
222
    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH                                                             \
223
    DOCTEST_MSVC_SUPPRESS_WARNING(4548) /* before comma no effect; expected side - effect */       \
224
    DOCTEST_MSVC_SUPPRESS_WARNING(4265) /* virtual functions, but destructor is not virtual */     \
225
    DOCTEST_MSVC_SUPPRESS_WARNING(4986) /* exception specification does not match previous */      \
226
    DOCTEST_MSVC_SUPPRESS_WARNING(4350) /* 'member1' called instead of 'member2' */                \
227
    DOCTEST_MSVC_SUPPRESS_WARNING(4668) /* not defined as a preprocessor macro */                  \
228
    DOCTEST_MSVC_SUPPRESS_WARNING(4365) /* signed/unsigned mismatch */                             \
229
    DOCTEST_MSVC_SUPPRESS_WARNING(4774) /* format string not a string literal */                   \
230
    DOCTEST_MSVC_SUPPRESS_WARNING(4820) /* padding */                                              \
231
    DOCTEST_MSVC_SUPPRESS_WARNING(4625) /* copy constructor was implicitly deleted */              \
232
    DOCTEST_MSVC_SUPPRESS_WARNING(4626) /* assignment operator was implicitly deleted */           \
233
    DOCTEST_MSVC_SUPPRESS_WARNING(5027) /* move assignment operator implicitly deleted */          \
234
    DOCTEST_MSVC_SUPPRESS_WARNING(5026) /* move constructor was implicitly deleted */              \
235
    DOCTEST_MSVC_SUPPRESS_WARNING(4623) /* default constructor was implicitly deleted */           \
236
    DOCTEST_MSVC_SUPPRESS_WARNING(5039) /* pointer to pot. throwing function passed to extern C */ \
237
    DOCTEST_MSVC_SUPPRESS_WARNING(5045) /* Spectre mitigation for memory load */                   \
238
    DOCTEST_MSVC_SUPPRESS_WARNING(5105) /* macro producing 'defined' has undefined behavior */     \
239
    DOCTEST_MSVC_SUPPRESS_WARNING(4738) /* storing float result in memory, loss of performance */
240

241
#define DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END DOCTEST_MSVC_SUPPRESS_WARNING_POP
242

243
// =================================================================================================
244
// == FEATURE DETECTION ============================================================================
245
// =================================================================================================
246

247
// general compiler feature support table: https://en.cppreference.com/w/cpp/compiler_support
248
// MSVC C++11 feature support table: https://msdn.microsoft.com/en-us/library/hh567368.aspx
249
// GCC C++11 feature support table: https://gcc.gnu.org/projects/cxx-status.html
250
// MSVC version table:
251
// https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering
252
// MSVC++ 14.3 (17) _MSC_VER == 1930 (Visual Studio 2022)
253
// MSVC++ 14.2 (16) _MSC_VER == 1920 (Visual Studio 2019)
254
// MSVC++ 14.1 (15) _MSC_VER == 1910 (Visual Studio 2017)
255
// MSVC++ 14.0      _MSC_VER == 1900 (Visual Studio 2015)
256
// MSVC++ 12.0      _MSC_VER == 1800 (Visual Studio 2013)
257
// MSVC++ 11.0      _MSC_VER == 1700 (Visual Studio 2012)
258
// MSVC++ 10.0      _MSC_VER == 1600 (Visual Studio 2010)
259
// MSVC++ 9.0       _MSC_VER == 1500 (Visual Studio 2008)
260
// MSVC++ 8.0       _MSC_VER == 1400 (Visual Studio 2005)
261

262
// Universal Windows Platform support
263
#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
264
#define DOCTEST_CONFIG_NO_WINDOWS_SEH
265
#endif // WINAPI_FAMILY
266
#if DOCTEST_MSVC && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
267
#define DOCTEST_CONFIG_WINDOWS_SEH
268
#endif // MSVC
269
#if defined(DOCTEST_CONFIG_NO_WINDOWS_SEH) && defined(DOCTEST_CONFIG_WINDOWS_SEH)
270
#undef DOCTEST_CONFIG_WINDOWS_SEH
271
#endif // DOCTEST_CONFIG_NO_WINDOWS_SEH
272

273
#if !defined(_WIN32) && !defined(__QNX__) && !defined(DOCTEST_CONFIG_POSIX_SIGNALS) &&             \
274
        !defined(__EMSCRIPTEN__) && !defined(__wasi__)
275
#define DOCTEST_CONFIG_POSIX_SIGNALS
276
#endif // _WIN32
277
#if defined(DOCTEST_CONFIG_NO_POSIX_SIGNALS) && defined(DOCTEST_CONFIG_POSIX_SIGNALS)
278
#undef DOCTEST_CONFIG_POSIX_SIGNALS
279
#endif // DOCTEST_CONFIG_NO_POSIX_SIGNALS
280

281
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
282
#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND)                   \
283
        || defined(__wasi__)
284
#define DOCTEST_CONFIG_NO_EXCEPTIONS
285
#endif // no exceptions
286
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
287

288
#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
289
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
290
#define DOCTEST_CONFIG_NO_EXCEPTIONS
291
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
292
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
293

294
#if defined(DOCTEST_CONFIG_NO_EXCEPTIONS) && !defined(DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS)
295
#define DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
296
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS && !DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
297

298
#ifdef __wasi__
299
#define DOCTEST_CONFIG_NO_MULTITHREADING
300
#endif
301

302
#if defined(DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN) && !defined(DOCTEST_CONFIG_IMPLEMENT)
303
#define DOCTEST_CONFIG_IMPLEMENT
304
#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
305

306
#if defined(_WIN32) || defined(__CYGWIN__)
307
#if DOCTEST_MSVC
308
#define DOCTEST_SYMBOL_EXPORT __declspec(dllexport)
309
#define DOCTEST_SYMBOL_IMPORT __declspec(dllimport)
310
#else // MSVC
311
#define DOCTEST_SYMBOL_EXPORT __attribute__((dllexport))
312
#define DOCTEST_SYMBOL_IMPORT __attribute__((dllimport))
313
#endif // MSVC
314
#else  // _WIN32
315
#define DOCTEST_SYMBOL_EXPORT __attribute__((visibility("default")))
316
#define DOCTEST_SYMBOL_IMPORT
317
#endif // _WIN32
318

319
#ifdef DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
320
#ifdef DOCTEST_CONFIG_IMPLEMENT
321
#define DOCTEST_INTERFACE DOCTEST_SYMBOL_EXPORT
322
#else // DOCTEST_CONFIG_IMPLEMENT
323
#define DOCTEST_INTERFACE DOCTEST_SYMBOL_IMPORT
324
#endif // DOCTEST_CONFIG_IMPLEMENT
325
#else  // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
326
#define DOCTEST_INTERFACE
327
#endif // DOCTEST_CONFIG_IMPLEMENTATION_IN_DLL
328

329
// needed for extern template instantiations
330
// see https://github.com/fmtlib/fmt/issues/2228
331
#if DOCTEST_MSVC
332
#define DOCTEST_INTERFACE_DECL
333
#define DOCTEST_INTERFACE_DEF DOCTEST_INTERFACE
334
#else // DOCTEST_MSVC
335
#define DOCTEST_INTERFACE_DECL DOCTEST_INTERFACE
336
#define DOCTEST_INTERFACE_DEF
337
#endif // DOCTEST_MSVC
338

339
#define DOCTEST_EMPTY
340

341
#if DOCTEST_MSVC
342
#define DOCTEST_NOINLINE __declspec(noinline)
343
#define DOCTEST_UNUSED
344
#define DOCTEST_ALIGNMENT(x)
345
#elif DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 5, 0)
346
#define DOCTEST_NOINLINE
347
#define DOCTEST_UNUSED
348
#define DOCTEST_ALIGNMENT(x)
349
#else
350
#define DOCTEST_NOINLINE __attribute__((noinline))
351
#define DOCTEST_UNUSED __attribute__((unused))
352
#define DOCTEST_ALIGNMENT(x) __attribute__((aligned(x)))
353
#endif
354

355
#ifndef DOCTEST_NORETURN
356
#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
357
#define DOCTEST_NORETURN
358
#else // DOCTEST_MSVC
359
#define DOCTEST_NORETURN [[noreturn]]
360
#endif // DOCTEST_MSVC
361
#endif // DOCTEST_NORETURN
362

363
#ifndef DOCTEST_NOEXCEPT
364
#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
365
#define DOCTEST_NOEXCEPT
366
#else // DOCTEST_MSVC
367
#define DOCTEST_NOEXCEPT noexcept
368
#endif // DOCTEST_MSVC
369
#endif // DOCTEST_NOEXCEPT
370

371
#ifndef DOCTEST_CONSTEXPR
372
#if DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
373
#define DOCTEST_CONSTEXPR const
374
#define DOCTEST_CONSTEXPR_FUNC inline
375
#else // DOCTEST_MSVC
376
#define DOCTEST_CONSTEXPR constexpr
377
#define DOCTEST_CONSTEXPR_FUNC constexpr
378
#endif // DOCTEST_MSVC
379
#endif // DOCTEST_CONSTEXPR
380

381
// =================================================================================================
382
// == FEATURE DETECTION END ========================================================================
383
// =================================================================================================
384

385
#define DOCTEST_DECLARE_INTERFACE(name)                                                            \
386
    virtual ~name();                                                                               \
387
    name() = default;                                                                              \
388
    name(const name&) = delete;                                                                    \
389
    name(name&&) = delete;                                                                         \
390
    name& operator=(const name&) = delete;                                                         \
391
    name& operator=(name&&) = delete;
392

393
#define DOCTEST_DEFINE_INTERFACE(name)                                                             \
394
    name::~name() = default;
395

396
// internal macros for string concatenation and anonymous variable name generation
397
#define DOCTEST_CAT_IMPL(s1, s2) s1##s2
398
#define DOCTEST_CAT(s1, s2) DOCTEST_CAT_IMPL(s1, s2)
399
#ifdef __COUNTER__ // not standard and may be missing for some compilers
400
#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __COUNTER__)
401
#else // __COUNTER__
402
#define DOCTEST_ANONYMOUS(x) DOCTEST_CAT(x, __LINE__)
403
#endif // __COUNTER__
404

405
#ifndef DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
406
#define DOCTEST_REF_WRAP(x) x&
407
#else // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
408
#define DOCTEST_REF_WRAP(x) x
409
#endif // DOCTEST_CONFIG_ASSERTION_PARAMETERS_BY_VALUE
410

411
// not using __APPLE__ because... this is how Catch does it
412
#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
413
#define DOCTEST_PLATFORM_MAC
414
#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
415
#define DOCTEST_PLATFORM_IPHONE
416
#elif defined(_WIN32)
417
#define DOCTEST_PLATFORM_WINDOWS
418
#elif defined(__wasi__)
419
#define DOCTEST_PLATFORM_WASI
420
#else // DOCTEST_PLATFORM
421
#define DOCTEST_PLATFORM_LINUX
422
#endif // DOCTEST_PLATFORM
423

424
namespace doctest { namespace detail {
425
    static DOCTEST_CONSTEXPR int consume(const int*, int) noexcept { return 0; }
426
}}
427

428
#define DOCTEST_GLOBAL_NO_WARNINGS(var, ...)                                                         \
429
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wglobal-constructors")                                \
430
    static const int var = doctest::detail::consume(&var, __VA_ARGS__);                              \
431
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
432

433
#ifndef DOCTEST_BREAK_INTO_DEBUGGER
434
// should probably take a look at https://github.com/scottt/debugbreak
435
#ifdef DOCTEST_PLATFORM_LINUX
436
#if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
437
// Break at the location of the failing check if possible
438
#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT(hicpp-no-assembler)
439
#else
440
#include <signal.h>
441
#define DOCTEST_BREAK_INTO_DEBUGGER() raise(SIGTRAP)
442
#endif
443
#elif defined(DOCTEST_PLATFORM_MAC)
444
#if defined(__x86_64) || defined(__x86_64__) || defined(__amd64__) || defined(__i386)
445
#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("int $3\n" : :) // NOLINT(hicpp-no-assembler)
446
#elif defined(__ppc__) || defined(__ppc64__)
447
// https://www.cocoawithlove.com/2008/03/break-into-debugger.html
448
#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n": : : "memory","r0","r3","r4") // NOLINT(hicpp-no-assembler)
449
#else
450
#define DOCTEST_BREAK_INTO_DEBUGGER() __asm__("brk #0"); // NOLINT(hicpp-no-assembler)
451
#endif
452
#elif DOCTEST_MSVC
453
#define DOCTEST_BREAK_INTO_DEBUGGER() __debugbreak()
454
#elif defined(__MINGW32__)
455
DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wredundant-decls")
456
extern "C" __declspec(dllimport) void __stdcall DebugBreak();
457
DOCTEST_GCC_SUPPRESS_WARNING_POP
458
#define DOCTEST_BREAK_INTO_DEBUGGER() ::DebugBreak()
459
#else // linux
460
#define DOCTEST_BREAK_INTO_DEBUGGER() (static_cast<void>(0))
461
#endif // linux
462
#endif // DOCTEST_BREAK_INTO_DEBUGGER
463

464
// this is kept here for backwards compatibility since the config option was changed
465
#ifdef DOCTEST_CONFIG_USE_IOSFWD
466
#ifndef DOCTEST_CONFIG_USE_STD_HEADERS
467
#define DOCTEST_CONFIG_USE_STD_HEADERS
468
#endif
469
#endif // DOCTEST_CONFIG_USE_IOSFWD
470

471
// for clang - always include ciso646 (which drags some std stuff) because
472
// we want to check if we are using libc++ with the _LIBCPP_VERSION macro in
473
// which case we don't want to forward declare stuff from std - for reference:
474
// https://github.com/doctest/doctest/issues/126
475
// https://github.com/doctest/doctest/issues/356
476
#if DOCTEST_CLANG
477
#include <ciso646>
478
#ifdef _LIBCPP_VERSION
479
#ifndef DOCTEST_CONFIG_USE_STD_HEADERS
480
#define DOCTEST_CONFIG_USE_STD_HEADERS
481
#endif
482
#endif // _LIBCPP_VERSION
483
#endif // clang
484

485
#ifdef DOCTEST_CONFIG_USE_STD_HEADERS
486
#ifndef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
487
#define DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
488
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
489
DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN
490
#include <cstddef>
491
#include <ostream>
492
#include <istream>
493
DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END
494
#else // DOCTEST_CONFIG_USE_STD_HEADERS
495

496
// Forward declaring 'X' in namespace std is not permitted by the C++ Standard.
497
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4643)
498

499
namespace std { // NOLINT(cert-dcl58-cpp)
500
typedef decltype(nullptr) nullptr_t; // NOLINT(modernize-use-using)
501
typedef decltype(sizeof(void*)) size_t; // NOLINT(modernize-use-using)
502
template <class charT>
503
struct char_traits;
504
template <>
505
struct char_traits<char>;
506
template <class charT, class traits>
507
class basic_ostream; // NOLINT(fuchsia-virtual-inheritance)
508
typedef basic_ostream<char, char_traits<char>> ostream; // NOLINT(modernize-use-using)
509
template<class traits>
510
// NOLINTNEXTLINE
511
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char*);
512
template <class charT, class traits>
513
class basic_istream;
514
typedef basic_istream<char, char_traits<char>> istream; // NOLINT(modernize-use-using)
515
template <class... Types>
516
class tuple;
517
#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
518
// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
519
template <class Ty>
520
class allocator;
521
template <class Elem, class Traits, class Alloc>
522
class basic_string;
523
using string = basic_string<char, char_traits<char>, allocator<char>>;
524
#endif // VS 2019
525
} // namespace std
526

527
DOCTEST_MSVC_SUPPRESS_WARNING_POP
528

529
#endif // DOCTEST_CONFIG_USE_STD_HEADERS
530

531
#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
532
#include <type_traits>
533
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
534

535
namespace doctest {
536

537
using std::size_t;
538

539
DOCTEST_INTERFACE extern bool is_running_in_test;
540

541
#ifndef DOCTEST_CONFIG_STRING_SIZE_TYPE
542
#define DOCTEST_CONFIG_STRING_SIZE_TYPE unsigned
543
#endif
544

545
// A 24 byte string class (can be as small as 17 for x64 and 13 for x86) that can hold strings with length
546
// of up to 23 chars on the stack before going on the heap - the last byte of the buffer is used for:
547
// - "is small" bit - the highest bit - if "0" then it is small - otherwise its "1" (128)
548
// - if small - capacity left before going on the heap - using the lowest 5 bits
549
// - if small - 2 bits are left unused - the second and third highest ones
550
// - if small - acts as a null terminator if strlen() is 23 (24 including the null terminator)
551
//              and the "is small" bit remains "0" ("as well as the capacity left") so its OK
552
// Idea taken from this lecture about the string implementation of facebook/folly - fbstring
553
// https://www.youtube.com/watch?v=kPR8h4-qZdk
554
// TODO:
555
// - optimizations - like not deleting memory unnecessarily in operator= and etc.
556
// - resize/reserve/clear
557
// - replace
558
// - back/front
559
// - iterator stuff
560
// - find & friends
561
// - push_back/pop_back
562
// - assign/insert/erase
563
// - relational operators as free functions - taking const char* as one of the params
564
class DOCTEST_INTERFACE String
565
{
566
public:
567
    using size_type = DOCTEST_CONFIG_STRING_SIZE_TYPE;
568

569
private:
570
    static DOCTEST_CONSTEXPR size_type len  = 24;      //!OCLINT avoid private static members
571
    static DOCTEST_CONSTEXPR size_type last = len - 1; //!OCLINT avoid private static members
572

573
    struct view // len should be more than sizeof(view) - because of the final byte for flags
574
    {
575
        char*    ptr;
576
        size_type size;
577
        size_type capacity;
578
    };
579

580
    union
581
    {
582
        char buf[len]; // NOLINT(*-avoid-c-arrays)
583
        view data;
584
    };
585

586
    char* allocate(size_type sz);
587

588
    bool isOnStack() const noexcept { return (buf[last] & 128) == 0; }
589
    void setOnHeap() noexcept;
590
    void setLast(size_type in = last) noexcept;
591
    void setSize(size_type sz) noexcept;
592

593
    void copy(const String& other);
594

595
public:
596
    static DOCTEST_CONSTEXPR size_type npos = static_cast<size_type>(-1);
597

598
    String() noexcept;
599
    ~String();
600

601
    // cppcheck-suppress noExplicitConstructor
602
    String(const char* in);
603
    String(const char* in, size_type in_size);
604

605
    String(std::istream& in, size_type in_size);
606

607
    String(const String& other);
608
    String& operator=(const String& other);
609

610
    String& operator+=(const String& other);
611

612
    String(String&& other) noexcept;
613
    String& operator=(String&& other) noexcept;
614

615
    char  operator[](size_type i) const;
616
    char& operator[](size_type i);
617

618
    // the only functions I'm willing to leave in the interface - available for inlining
619
    const char* c_str() const { return const_cast<String*>(this)->c_str(); } // NOLINT
620
    char*       c_str() {
621
        if (isOnStack()) {
622
            return reinterpret_cast<char*>(buf);
623
        }
624
        return data.ptr;
625
    }
626

627
    size_type size() const;
628
    size_type capacity() const;
629

630
    String substr(size_type pos, size_type cnt = npos) &&;
631
    String substr(size_type pos, size_type cnt = npos) const &;
632

633
    size_type find(char ch, size_type pos = 0) const;
634
    size_type rfind(char ch, size_type pos = npos) const;
635

636
    int compare(const char* other, bool no_case = false) const;
637
    int compare(const String& other, bool no_case = false) const;
638

639
friend DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, const String& in);
640
};
641

642
DOCTEST_INTERFACE String operator+(const String& lhs, const String& rhs);
643

644
DOCTEST_INTERFACE bool operator==(const String& lhs, const String& rhs);
645
DOCTEST_INTERFACE bool operator!=(const String& lhs, const String& rhs);
646
DOCTEST_INTERFACE bool operator<(const String& lhs, const String& rhs);
647
DOCTEST_INTERFACE bool operator>(const String& lhs, const String& rhs);
648
DOCTEST_INTERFACE bool operator<=(const String& lhs, const String& rhs);
649
DOCTEST_INTERFACE bool operator>=(const String& lhs, const String& rhs);
650

651
class DOCTEST_INTERFACE Contains {
652
public:
653
    explicit Contains(const String& string);
654

655
    bool checkWith(const String& other) const;
656

657
    String string;
658
};
659

660
DOCTEST_INTERFACE String toString(const Contains& in);
661

662
DOCTEST_INTERFACE bool operator==(const String& lhs, const Contains& rhs);
663
DOCTEST_INTERFACE bool operator==(const Contains& lhs, const String& rhs);
664
DOCTEST_INTERFACE bool operator!=(const String& lhs, const Contains& rhs);
665
DOCTEST_INTERFACE bool operator!=(const Contains& lhs, const String& rhs);
666

667
namespace Color {
668
    enum Enum
669
    {
670
        None = 0,
671
        White,
672
        Red,
673
        Green,
674
        Blue,
675
        Cyan,
676
        Yellow,
677
        Grey,
678

679
        Bright = 0x10,
680

681
        BrightRed   = Bright | Red,
682
        BrightGreen = Bright | Green,
683
        LightGrey   = Bright | Grey,
684
        BrightWhite = Bright | White
685
    };
686

687
    DOCTEST_INTERFACE std::ostream& operator<<(std::ostream& s, Color::Enum code);
688
} // namespace Color
689

690
namespace assertType {
691
    enum Enum
692
    {
693
        // macro traits
694

695
        is_warn    = 1,
696
        is_check   = 2 * is_warn,
697
        is_require = 2 * is_check,
698

699
        is_normal      = 2 * is_require,
700
        is_throws      = 2 * is_normal,
701
        is_throws_as   = 2 * is_throws,
702
        is_throws_with = 2 * is_throws_as,
703
        is_nothrow     = 2 * is_throws_with,
704

705
        is_false = 2 * is_nothrow,
706
        is_unary = 2 * is_false, // not checked anywhere - used just to distinguish the types
707

708
        is_eq = 2 * is_unary,
709
        is_ne = 2 * is_eq,
710

711
        is_lt = 2 * is_ne,
712
        is_gt = 2 * is_lt,
713

714
        is_ge = 2 * is_gt,
715
        is_le = 2 * is_ge,
716

717
        // macro types
718

719
        DT_WARN    = is_normal | is_warn,
720
        DT_CHECK   = is_normal | is_check,
721
        DT_REQUIRE = is_normal | is_require,
722

723
        DT_WARN_FALSE    = is_normal | is_false | is_warn,
724
        DT_CHECK_FALSE   = is_normal | is_false | is_check,
725
        DT_REQUIRE_FALSE = is_normal | is_false | is_require,
726

727
        DT_WARN_THROWS    = is_throws | is_warn,
728
        DT_CHECK_THROWS   = is_throws | is_check,
729
        DT_REQUIRE_THROWS = is_throws | is_require,
730

731
        DT_WARN_THROWS_AS    = is_throws_as | is_warn,
732
        DT_CHECK_THROWS_AS   = is_throws_as | is_check,
733
        DT_REQUIRE_THROWS_AS = is_throws_as | is_require,
734

735
        DT_WARN_THROWS_WITH    = is_throws_with | is_warn,
736
        DT_CHECK_THROWS_WITH   = is_throws_with | is_check,
737
        DT_REQUIRE_THROWS_WITH = is_throws_with | is_require,
738

739
        DT_WARN_THROWS_WITH_AS    = is_throws_with | is_throws_as | is_warn,
740
        DT_CHECK_THROWS_WITH_AS   = is_throws_with | is_throws_as | is_check,
741
        DT_REQUIRE_THROWS_WITH_AS = is_throws_with | is_throws_as | is_require,
742

743
        DT_WARN_NOTHROW    = is_nothrow | is_warn,
744
        DT_CHECK_NOTHROW   = is_nothrow | is_check,
745
        DT_REQUIRE_NOTHROW = is_nothrow | is_require,
746

747
        DT_WARN_EQ    = is_normal | is_eq | is_warn,
748
        DT_CHECK_EQ   = is_normal | is_eq | is_check,
749
        DT_REQUIRE_EQ = is_normal | is_eq | is_require,
750

751
        DT_WARN_NE    = is_normal | is_ne | is_warn,
752
        DT_CHECK_NE   = is_normal | is_ne | is_check,
753
        DT_REQUIRE_NE = is_normal | is_ne | is_require,
754

755
        DT_WARN_GT    = is_normal | is_gt | is_warn,
756
        DT_CHECK_GT   = is_normal | is_gt | is_check,
757
        DT_REQUIRE_GT = is_normal | is_gt | is_require,
758

759
        DT_WARN_LT    = is_normal | is_lt | is_warn,
760
        DT_CHECK_LT   = is_normal | is_lt | is_check,
761
        DT_REQUIRE_LT = is_normal | is_lt | is_require,
762

763
        DT_WARN_GE    = is_normal | is_ge | is_warn,
764
        DT_CHECK_GE   = is_normal | is_ge | is_check,
765
        DT_REQUIRE_GE = is_normal | is_ge | is_require,
766

767
        DT_WARN_LE    = is_normal | is_le | is_warn,
768
        DT_CHECK_LE   = is_normal | is_le | is_check,
769
        DT_REQUIRE_LE = is_normal | is_le | is_require,
770

771
        DT_WARN_UNARY    = is_normal | is_unary | is_warn,
772
        DT_CHECK_UNARY   = is_normal | is_unary | is_check,
773
        DT_REQUIRE_UNARY = is_normal | is_unary | is_require,
774

775
        DT_WARN_UNARY_FALSE    = is_normal | is_false | is_unary | is_warn,
776
        DT_CHECK_UNARY_FALSE   = is_normal | is_false | is_unary | is_check,
777
        DT_REQUIRE_UNARY_FALSE = is_normal | is_false | is_unary | is_require,
778
    };
779
} // namespace assertType
780

781
DOCTEST_INTERFACE const char* assertString(assertType::Enum at);
782
DOCTEST_INTERFACE const char* failureString(assertType::Enum at);
783
DOCTEST_INTERFACE const char* skipPathFromFilename(const char* file);
784

785
struct DOCTEST_INTERFACE TestCaseData
786
{
787
    String      m_file;       // the file in which the test was registered (using String - see #350)
788
    unsigned    m_line;       // the line where the test was registered
789
    const char* m_name;       // name of the test case
790
    const char* m_test_suite; // the test suite in which the test was added
791
    const char* m_description;
792
    bool        m_skip;
793
    bool        m_no_breaks;
794
    bool        m_no_output;
795
    bool        m_may_fail;
796
    bool        m_should_fail;
797
    int         m_expected_failures;
798
    double      m_timeout;
799
};
800

801
struct DOCTEST_INTERFACE AssertData
802
{
803
    // common - for all asserts
804
    const TestCaseData* m_test_case;
805
    assertType::Enum    m_at;
806
    const char*         m_file;
807
    int                 m_line;
808
    const char*         m_expr;
809
    bool                m_failed;
810

811
    // exception-related - for all asserts
812
    bool   m_threw;
813
    String m_exception;
814

815
    // for normal asserts
816
    String m_decomp;
817

818
    // for specific exception-related asserts
819
    bool           m_threw_as;
820
    const char*    m_exception_type;
821

822
    class DOCTEST_INTERFACE StringContains {
823
        private:
824
            Contains content;
825
            bool isContains;
826

827
        public:
828
            StringContains(const String& str) : content(str), isContains(false) { }
829
            StringContains(Contains cntn) : content(static_cast<Contains&&>(cntn)), isContains(true) { }
830

831
            bool check(const String& str) { return isContains ? (content == str) : (content.string == str); }
832

833
            operator const String&() const { return content.string; }
834

835
            const char* c_str() const { return content.string.c_str(); }
836
    } m_exception_string;
837

838
    AssertData(assertType::Enum at, const char* file, int line, const char* expr,
839
        const char* exception_type, const StringContains& exception_string);
840
};
841

842
struct DOCTEST_INTERFACE MessageData
843
{
844
    String           m_string;
845
    const char*      m_file;
846
    int              m_line;
847
    assertType::Enum m_severity;
848
};
849

850
struct DOCTEST_INTERFACE SubcaseSignature
851
{
852
    String      m_name;
853
    const char* m_file;
854
    int         m_line;
855

856
    bool operator==(const SubcaseSignature& other) const;
857
    bool operator<(const SubcaseSignature& other) const;
858
};
859

860
struct DOCTEST_INTERFACE IContextScope
861
{
862
    DOCTEST_DECLARE_INTERFACE(IContextScope)
863
    virtual void stringify(std::ostream*) const = 0;
864
};
865

866
namespace detail {
867
    struct DOCTEST_INTERFACE TestCase;
868
} // namespace detail
869

870
struct ContextOptions //!OCLINT too many fields
871
{
872
    std::ostream* cout = nullptr; // stdout stream
873
    String        binary_name;    // the test binary name
874

875
    const detail::TestCase* currentTest = nullptr;
876

877
    // == parameters from the command line
878
    String   out;       // output filename
879
    String   order_by;  // how tests should be ordered
880
    unsigned rand_seed; // the seed for rand ordering
881

882
    unsigned first; // the first (matching) test to be executed
883
    unsigned last;  // the last (matching) test to be executed
884

885
    int abort_after;           // stop tests after this many failed assertions
886
    int subcase_filter_levels; // apply the subcase filters for the first N levels
887

888
    bool success;              // include successful assertions in output
889
    bool case_sensitive;       // if filtering should be case sensitive
890
    bool exit;                 // if the program should be exited after the tests are ran/whatever
891
    bool duration;             // print the time duration of each test case
892
    bool minimal;              // minimal console output (only test failures)
893
    bool quiet;                // no console output
894
    bool no_throw;             // to skip exceptions-related assertion macros
895
    bool no_exitcode;          // if the framework should return 0 as the exitcode
896
    bool no_run;               // to not run the tests at all (can be done with an "*" exclude)
897
    bool no_intro;             // to not print the intro of the framework
898
    bool no_version;           // to not print the version of the framework
899
    bool no_colors;            // if output to the console should be colorized
900
    bool force_colors;         // forces the use of colors even when a tty cannot be detected
901
    bool no_breaks;            // to not break into the debugger
902
    bool no_skip;              // don't skip test cases which are marked to be skipped
903
    bool gnu_file_line;        // if line numbers should be surrounded with :x: and not (x):
904
    bool no_path_in_filenames; // if the path to files should be removed from the output
905
    bool no_line_numbers;      // if source code line numbers should be omitted from the output
906
    bool no_debug_output;      // no output in the debug console when a debugger is attached
907
    bool no_skipped_summary;   // don't print "skipped" in the summary !!! UNDOCUMENTED !!!
908
    bool no_time_in_output;    // omit any time/timestamps from output !!! UNDOCUMENTED !!!
909

910
    bool help;             // to print the help
911
    bool version;          // to print the version
912
    bool count;            // if only the count of matching tests is to be retrieved
913
    bool list_test_cases;  // to list all tests matching the filters
914
    bool list_test_suites; // to list all suites matching the filters
915
    bool list_reporters;   // lists all registered reporters
916
};
917

918
namespace detail {
919
    namespace types {
920
#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
921
        using namespace std;
922
#else
923
        template <bool COND, typename T = void>
924
        struct enable_if { };
925

926
        template <typename T>
927
        struct enable_if<true, T> { using type = T; };
928

929
        struct true_type { static DOCTEST_CONSTEXPR bool value = true; };
930
        struct false_type { static DOCTEST_CONSTEXPR bool value = false; };
931

932
        template <typename T> struct remove_reference { using type = T; };
933
        template <typename T> struct remove_reference<T&> { using type = T; };
934
        template <typename T> struct remove_reference<T&&> { using type = T; };
935

936
        template <typename T> struct is_rvalue_reference : false_type { };
937
        template <typename T> struct is_rvalue_reference<T&&> : true_type { };
938

939
        template<typename T> struct remove_const { using type = T; };
940
        template <typename T> struct remove_const<const T> { using type = T; };
941

942
        // Compiler intrinsics
943
        template <typename T> struct is_enum { static DOCTEST_CONSTEXPR bool value = __is_enum(T); };
944
        template <typename T> struct underlying_type { using type = __underlying_type(T); };
945

946
        template <typename T> struct is_pointer : false_type { };
947
        template <typename T> struct is_pointer<T*> : true_type { };
948

949
        template <typename T> struct is_array : false_type { };
950
        // NOLINTNEXTLINE(*-avoid-c-arrays)
951
        template <typename T, size_t SIZE> struct is_array<T[SIZE]> : true_type { };
952
#endif
953
    }
954

955
    // <utility>
956
    template <typename T>
957
    T&& declval();
958

959
    template <class T>
960
    DOCTEST_CONSTEXPR_FUNC T&& forward(typename types::remove_reference<T>::type& t) DOCTEST_NOEXCEPT {
961
        return static_cast<T&&>(t);
962
    }
963

964
    template <class T>
965
    DOCTEST_CONSTEXPR_FUNC T&& forward(typename types::remove_reference<T>::type&& t) DOCTEST_NOEXCEPT {
966
        return static_cast<T&&>(t);
967
    }
968

969
    template <typename T>
970
    struct deferred_false : types::false_type { };
971

972
// MSVS 2015 :(
973
#if defined(_MSC_VER) && _MSC_VER <= 1900
974
    template <typename T, typename = void>
975
    struct has_global_insertion_operator : types::false_type { };
976

977
    template <typename T>
978
    struct has_global_insertion_operator<T, decltype(::operator<<(declval<std::ostream&>(), declval<const T&>()), void())> : types::true_type { };
979

980
    template <typename T, typename = void>
981
    struct has_insertion_operator { static DOCTEST_CONSTEXPR bool value = has_global_insertion_operator<T>::value; };
982

983
    template <typename T, bool global>
984
    struct insert_hack;
985

986
    template <typename T>
987
    struct insert_hack<T, true> {
988
        static void insert(std::ostream& os, const T& t) { ::operator<<(os, t); }
989
    };
990

991
    template <typename T>
992
    struct insert_hack<T, false> {
993
        static void insert(std::ostream& os, const T& t) { operator<<(os, t); }
994
    };
995

996
    template <typename T>
997
    using insert_hack_t = insert_hack<T, has_global_insertion_operator<T>::value>;
998
#else
999
    template <typename T, typename = void>
1000
    struct has_insertion_operator : types::false_type { };
1001
#endif
1002

1003
template <typename T>
1004
struct has_insertion_operator<T, decltype(operator<<(declval<std::ostream&>(), declval<const T&>()), void())> : types::true_type { };
1005

1006
    DOCTEST_INTERFACE std::ostream* tlssPush();
1007
    DOCTEST_INTERFACE String tlssPop();
1008

1009
    template <bool C>
1010
    struct StringMakerBase {
1011
        template <typename T>
1012
        static String convert(const DOCTEST_REF_WRAP(T)) {
1013
#ifdef DOCTEST_CONFIG_REQUIRE_STRINGIFICATION_FOR_ALL_USED_TYPES
1014
            static_assert(deferred_false<T>::value, "No stringification detected for type T. See string conversion manual");
1015
#endif
1016
            return "{?}";
1017
        }
1018
    };
1019

1020
    template <typename T>
1021
    struct filldata;
1022

1023
    template <typename T>
1024
    void filloss(std::ostream* stream, const T& in) {
1025
        filldata<T>::fill(stream, in);
1026
    }
1027

1028
    template <typename T, size_t N>
1029
    void filloss(std::ostream* stream, const T (&in)[N]) { // NOLINT(*-avoid-c-arrays)
1030
        // T[N], T(&)[N], T(&&)[N] have same behaviour.
1031
        // Hence remove reference.
1032
        filloss<typename types::remove_reference<decltype(in)>::type>(stream, in);
1033
    }
1034

1035
    template <typename T>
1036
    String toStream(const T& in) {
1037
        std::ostream* stream = tlssPush();
1038
        filloss(stream, in);
1039
        return tlssPop();
1040
    }
1041

1042
    template <>
1043
    struct StringMakerBase<true> {
1044
        template <typename T>
1045
        static String convert(const DOCTEST_REF_WRAP(T) in) {
1046
            return toStream(in);
1047
        }
1048
    };
1049
} // namespace detail
1050

1051
template <typename T>
1052
struct StringMaker : public detail::StringMakerBase<
1053
    detail::has_insertion_operator<T>::value || detail::types::is_pointer<T>::value || detail::types::is_array<T>::value>
1054
{};
1055

1056
#ifndef DOCTEST_STRINGIFY
1057
#ifdef DOCTEST_CONFIG_DOUBLE_STRINGIFY
1058
#define DOCTEST_STRINGIFY(...) toString(toString(__VA_ARGS__))
1059
#else
1060
#define DOCTEST_STRINGIFY(...) toString(__VA_ARGS__)
1061
#endif
1062
#endif
1063

1064
template <typename T>
1065
String toString() {
1066
#if DOCTEST_MSVC >= 0 && DOCTEST_CLANG == 0 && DOCTEST_GCC == 0
1067
    String ret = __FUNCSIG__; // class doctest::String __cdecl doctest::toString<TYPE>(void)
1068
    String::size_type beginPos = ret.find('<');
1069
    return ret.substr(beginPos + 1, ret.size() - beginPos - static_cast<String::size_type>(sizeof(">(void)")));
1070
#else
1071
    String ret = __PRETTY_FUNCTION__; // doctest::String toString() [with T = TYPE]
1072
    String::size_type begin = ret.find('=') + 2;
1073
    return ret.substr(begin, ret.size() - begin - 1);
1074
#endif
1075
}
1076

1077
template <typename T, typename detail::types::enable_if<!detail::types::is_enum<T>::value, bool>::type = true>
1078
String toString(const DOCTEST_REF_WRAP(T) value) {
1079
    return StringMaker<T>::convert(value);
1080
}
1081

1082
#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1083
DOCTEST_INTERFACE String toString(const char* in);
1084
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1085

1086
#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
1087
// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
1088
DOCTEST_INTERFACE String toString(const std::string& in);
1089
#endif // VS 2019
1090

1091
DOCTEST_INTERFACE String toString(String in);
1092

1093
DOCTEST_INTERFACE String toString(std::nullptr_t);
1094

1095
DOCTEST_INTERFACE String toString(bool in);
1096

1097
DOCTEST_INTERFACE String toString(float in);
1098
DOCTEST_INTERFACE String toString(double in);
1099
DOCTEST_INTERFACE String toString(double long in);
1100

1101
DOCTEST_INTERFACE String toString(char in);
1102
DOCTEST_INTERFACE String toString(char signed in);
1103
DOCTEST_INTERFACE String toString(char unsigned in);
1104
DOCTEST_INTERFACE String toString(short in);
1105
DOCTEST_INTERFACE String toString(short unsigned in);
1106
DOCTEST_INTERFACE String toString(signed in);
1107
DOCTEST_INTERFACE String toString(unsigned in);
1108
DOCTEST_INTERFACE String toString(long in);
1109
DOCTEST_INTERFACE String toString(long unsigned in);
1110
DOCTEST_INTERFACE String toString(long long in);
1111
DOCTEST_INTERFACE String toString(long long unsigned in);
1112

1113
template <typename T, typename detail::types::enable_if<detail::types::is_enum<T>::value, bool>::type = true>
1114
String toString(const DOCTEST_REF_WRAP(T) value) {
1115
    using UT = typename detail::types::underlying_type<T>::type;
1116
    return (DOCTEST_STRINGIFY(static_cast<UT>(value)));
1117
}
1118

1119
namespace detail {
1120
    template <typename T>
1121
    struct filldata
1122
    {
1123
        static void fill(std::ostream* stream, const T& in) {
1124
#if defined(_MSC_VER) && _MSC_VER <= 1900
1125
        insert_hack_t<T>::insert(*stream, in);
1126
#else
1127
        operator<<(*stream, in);
1128
#endif
1129
        }
1130
    };
1131

1132
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4866)
1133
// NOLINTBEGIN(*-avoid-c-arrays)
1134
    template <typename T, size_t N>
1135
    struct filldata<T[N]> {
1136
        static void fill(std::ostream* stream, const T(&in)[N]) {
1137
            *stream << "[";
1138
            for (size_t i = 0; i < N; i++) {
1139
                if (i != 0) { *stream << ", "; }
1140
                *stream << (DOCTEST_STRINGIFY(in[i]));
1141
            }
1142
            *stream << "]";
1143
        }
1144
    };
1145
// NOLINTEND(*-avoid-c-arrays)
1146
DOCTEST_MSVC_SUPPRESS_WARNING_POP
1147

1148
    // Specialized since we don't want the terminating null byte!
1149
// NOLINTBEGIN(*-avoid-c-arrays)
1150
    template <size_t N>
1151
    struct filldata<const char[N]> {
1152
        static void fill(std::ostream* stream, const char (&in)[N]) {
1153
            *stream << String(in, in[N - 1] ? N : N - 1);
1154
        } // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
1155
    };
1156
// NOLINTEND(*-avoid-c-arrays)
1157

1158
    template <>
1159
    struct filldata<const void*> {
1160
        static void fill(std::ostream* stream, const void* in);
1161
    };
1162

1163
    template <typename T>
1164
    struct filldata<T*> {
1165
        static void fill(std::ostream* stream, const T* in) {
1166
            filldata<const void*>::fill(stream, in);
1167
        }
1168
    };
1169
}
1170

1171
struct DOCTEST_INTERFACE Approx
1172
{
1173
    Approx(double value);
1174

1175
    Approx operator()(double value) const;
1176

1177
#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1178
    template <typename T>
1179
    explicit Approx(const T& value,
1180
                    typename detail::types::enable_if<std::is_constructible<double, T>::value>::type* =
1181
                            static_cast<T*>(nullptr)) {
1182
        *this = static_cast<double>(value);
1183
    }
1184
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1185

1186
    Approx& epsilon(double newEpsilon);
1187

1188
#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1189
    template <typename T>
1190
    typename std::enable_if<std::is_constructible<double, T>::value, Approx&>::type epsilon(
1191
            const T& newEpsilon) {
1192
        m_epsilon = static_cast<double>(newEpsilon);
1193
        return *this;
1194
    }
1195
#endif //  DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1196

1197
    Approx& scale(double newScale);
1198

1199
#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1200
    template <typename T>
1201
    typename std::enable_if<std::is_constructible<double, T>::value, Approx&>::type scale(
1202
            const T& newScale) {
1203
        m_scale = static_cast<double>(newScale);
1204
        return *this;
1205
    }
1206
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1207

1208
    // clang-format off
1209
    DOCTEST_INTERFACE friend bool operator==(double lhs, const Approx & rhs);
1210
    DOCTEST_INTERFACE friend bool operator==(const Approx & lhs, double rhs);
1211
    DOCTEST_INTERFACE friend bool operator!=(double lhs, const Approx & rhs);
1212
    DOCTEST_INTERFACE friend bool operator!=(const Approx & lhs, double rhs);
1213
    DOCTEST_INTERFACE friend bool operator<=(double lhs, const Approx & rhs);
1214
    DOCTEST_INTERFACE friend bool operator<=(const Approx & lhs, double rhs);
1215
    DOCTEST_INTERFACE friend bool operator>=(double lhs, const Approx & rhs);
1216
    DOCTEST_INTERFACE friend bool operator>=(const Approx & lhs, double rhs);
1217
    DOCTEST_INTERFACE friend bool operator< (double lhs, const Approx & rhs);
1218
    DOCTEST_INTERFACE friend bool operator< (const Approx & lhs, double rhs);
1219
    DOCTEST_INTERFACE friend bool operator> (double lhs, const Approx & rhs);
1220
    DOCTEST_INTERFACE friend bool operator> (const Approx & lhs, double rhs);
1221

1222
#ifdef DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1223
#define DOCTEST_APPROX_PREFIX \
1224
    template <typename T> friend typename std::enable_if<std::is_constructible<double, T>::value, bool>::type
1225

1226
    DOCTEST_APPROX_PREFIX operator==(const T& lhs, const Approx& rhs) { return operator==(static_cast<double>(lhs), rhs); }
1227
    DOCTEST_APPROX_PREFIX operator==(const Approx& lhs, const T& rhs) { return operator==(rhs, lhs); }
1228
    DOCTEST_APPROX_PREFIX operator!=(const T& lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
1229
    DOCTEST_APPROX_PREFIX operator!=(const Approx& lhs, const T& rhs) { return !operator==(rhs, lhs); }
1230
    DOCTEST_APPROX_PREFIX operator<=(const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) < rhs.m_value || lhs == rhs; }
1231
    DOCTEST_APPROX_PREFIX operator<=(const Approx& lhs, const T& rhs) { return lhs.m_value < static_cast<double>(rhs) || lhs == rhs; }
1232
    DOCTEST_APPROX_PREFIX operator>=(const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) > rhs.m_value || lhs == rhs; }
1233
    DOCTEST_APPROX_PREFIX operator>=(const Approx& lhs, const T& rhs) { return lhs.m_value > static_cast<double>(rhs) || lhs == rhs; }
1234
    DOCTEST_APPROX_PREFIX operator< (const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) < rhs.m_value && lhs != rhs; }
1235
    DOCTEST_APPROX_PREFIX operator< (const Approx& lhs, const T& rhs) { return lhs.m_value < static_cast<double>(rhs) && lhs != rhs; }
1236
    DOCTEST_APPROX_PREFIX operator> (const T& lhs, const Approx& rhs) { return static_cast<double>(lhs) > rhs.m_value && lhs != rhs; }
1237
    DOCTEST_APPROX_PREFIX operator> (const Approx& lhs, const T& rhs) { return lhs.m_value > static_cast<double>(rhs) && lhs != rhs; }
1238
#undef DOCTEST_APPROX_PREFIX
1239
#endif // DOCTEST_CONFIG_INCLUDE_TYPE_TRAITS
1240

1241
    // clang-format on
1242

1243
    double m_epsilon;
1244
    double m_scale;
1245
    double m_value;
1246
};
1247

1248
DOCTEST_INTERFACE String toString(const Approx& in);
1249

1250
DOCTEST_INTERFACE const ContextOptions* getContextOptions();
1251

1252
template <typename F>
1253
struct DOCTEST_INTERFACE_DECL IsNaN
1254
{
1255
    F value; bool flipped;
1256
    IsNaN(F f, bool flip = false) : value(f), flipped(flip) { }
1257
    IsNaN<F> operator!() const { return { value, !flipped }; }
1258
    operator bool() const;
1259
};
1260
#ifndef __MINGW32__
1261
extern template struct DOCTEST_INTERFACE_DECL IsNaN<float>;
1262
extern template struct DOCTEST_INTERFACE_DECL IsNaN<double>;
1263
extern template struct DOCTEST_INTERFACE_DECL IsNaN<long double>;
1264
#endif
1265
DOCTEST_INTERFACE String toString(IsNaN<float> in);
1266
DOCTEST_INTERFACE String toString(IsNaN<double> in);
1267
DOCTEST_INTERFACE String toString(IsNaN<double long> in);
1268

1269
#ifndef DOCTEST_CONFIG_DISABLE
1270

1271
namespace detail {
1272
    // clang-format off
1273
#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1274
    template<class T>               struct decay_array       { using type = T; };
1275
    template<class T, unsigned N>   struct decay_array<T[N]> { using type = T*; };
1276
    template<class T>               struct decay_array<T[]>  { using type = T*; };
1277

1278
    template<class T>   struct not_char_pointer              { static DOCTEST_CONSTEXPR value = 1; };
1279
    template<>          struct not_char_pointer<char*>       { static DOCTEST_CONSTEXPR value = 0; };
1280
    template<>          struct not_char_pointer<const char*> { static DOCTEST_CONSTEXPR value = 0; };
1281

1282
    template<class T> struct can_use_op : public not_char_pointer<typename decay_array<T>::type> {};
1283
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1284
    // clang-format on
1285

1286
    struct DOCTEST_INTERFACE TestFailureException
1287
    {
1288
    };
1289

1290
    DOCTEST_INTERFACE bool checkIfShouldThrow(assertType::Enum at);
1291

1292
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
1293
    DOCTEST_NORETURN
1294
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
1295
    DOCTEST_INTERFACE void throwException();
1296

1297
    struct DOCTEST_INTERFACE Subcase
1298
    {
1299
        SubcaseSignature m_signature;
1300
        bool             m_entered = false;
1301

1302
        Subcase(const String& name, const char* file, int line);
1303
        Subcase(const Subcase&) = delete;
1304
        Subcase(Subcase&&) = delete;
1305
        Subcase& operator=(const Subcase&) = delete;
1306
        Subcase& operator=(Subcase&&) = delete;
1307
        ~Subcase();
1308

1309
        operator bool() const;
1310

1311
        private:
1312
            bool checkFilters();
1313
    };
1314

1315
    template <typename L, typename R>
1316
    String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
1317
                               const DOCTEST_REF_WRAP(R) rhs) {
1318
        return (DOCTEST_STRINGIFY(lhs)) + op + (DOCTEST_STRINGIFY(rhs));
1319
    }
1320

1321
#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0)
1322
DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-comparison")
1323
#endif
1324

1325
// This will check if there is any way it could find a operator like member or friend and uses it.
1326
// If not it doesn't find the operator or if the operator at global scope is defined after
1327
// this template, the template won't be instantiated due to SFINAE. Once the template is not
1328
// instantiated it can look for global operator using normal conversions.
1329
#define SFINAE_OP(ret,op) decltype((void)(doctest::detail::declval<L>() op doctest::detail::declval<R>()),ret{})
1330

1331
#define DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(op, op_str, op_macro)                              \
1332
    template <typename R>                                                                          \
1333
    DOCTEST_NOINLINE SFINAE_OP(Result,op) operator op(R&& rhs) {                                   \
1334
    bool res = op_macro(doctest::detail::forward<const L>(lhs), doctest::detail::forward<R>(rhs)); \
1335
        if(m_at & assertType::is_false)                                                            \
1336
            res = !res;                                                                            \
1337
        if(!res || doctest::getContextOptions()->success)                                          \
1338
            return Result(res, stringifyBinaryExpr(lhs, op_str, rhs));                             \
1339
        return Result(res);                                                                        \
1340
    }
1341

1342
    // more checks could be added - like in Catch:
1343
    // https://github.com/catchorg/Catch2/pull/1480/files
1344
    // https://github.com/catchorg/Catch2/pull/1481/files
1345
#define DOCTEST_FORBIT_EXPRESSION(rt, op)                                                          \
1346
    template <typename R>                                                                          \
1347
    rt& operator op(const R&) {                                                                    \
1348
        static_assert(deferred_false<R>::value,                                                    \
1349
                      "Expression Too Complex Please Rewrite As Binary Comparison!");              \
1350
        return *this;                                                                              \
1351
    }
1352

1353
    struct DOCTEST_INTERFACE Result // NOLINT(*-member-init)
1354
    {
1355
        bool   m_passed;
1356
        String m_decomp;
1357

1358
        Result() = default; // TODO: Why do we need this? (To remove NOLINT)
1359
        Result(bool passed, const String& decomposition = String());
1360

1361
        // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence
1362
        DOCTEST_FORBIT_EXPRESSION(Result, &)
1363
        DOCTEST_FORBIT_EXPRESSION(Result, ^)
1364
        DOCTEST_FORBIT_EXPRESSION(Result, |)
1365
        DOCTEST_FORBIT_EXPRESSION(Result, &&)
1366
        DOCTEST_FORBIT_EXPRESSION(Result, ||)
1367
        DOCTEST_FORBIT_EXPRESSION(Result, ==)
1368
        DOCTEST_FORBIT_EXPRESSION(Result, !=)
1369
        DOCTEST_FORBIT_EXPRESSION(Result, <)
1370
        DOCTEST_FORBIT_EXPRESSION(Result, >)
1371
        DOCTEST_FORBIT_EXPRESSION(Result, <=)
1372
        DOCTEST_FORBIT_EXPRESSION(Result, >=)
1373
        DOCTEST_FORBIT_EXPRESSION(Result, =)
1374
        DOCTEST_FORBIT_EXPRESSION(Result, +=)
1375
        DOCTEST_FORBIT_EXPRESSION(Result, -=)
1376
        DOCTEST_FORBIT_EXPRESSION(Result, *=)
1377
        DOCTEST_FORBIT_EXPRESSION(Result, /=)
1378
        DOCTEST_FORBIT_EXPRESSION(Result, %=)
1379
        DOCTEST_FORBIT_EXPRESSION(Result, <<=)
1380
        DOCTEST_FORBIT_EXPRESSION(Result, >>=)
1381
        DOCTEST_FORBIT_EXPRESSION(Result, &=)
1382
        DOCTEST_FORBIT_EXPRESSION(Result, ^=)
1383
        DOCTEST_FORBIT_EXPRESSION(Result, |=)
1384
    };
1385

1386
#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
1387

1388
    DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
1389
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
1390
    DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-compare")
1391
    //DOCTEST_CLANG_SUPPRESS_WARNING("-Wdouble-promotion")
1392
    //DOCTEST_CLANG_SUPPRESS_WARNING("-Wconversion")
1393
    //DOCTEST_CLANG_SUPPRESS_WARNING("-Wfloat-equal")
1394

1395
    DOCTEST_GCC_SUPPRESS_WARNING_PUSH
1396
    DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
1397
    DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-compare")
1398
    //DOCTEST_GCC_SUPPRESS_WARNING("-Wdouble-promotion")
1399
    //DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
1400
    //DOCTEST_GCC_SUPPRESS_WARNING("-Wfloat-equal")
1401

1402
    DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
1403
    // https://stackoverflow.com/questions/39479163 what's the difference between 4018 and 4389
1404
    DOCTEST_MSVC_SUPPRESS_WARNING(4388) // signed/unsigned mismatch
1405
    DOCTEST_MSVC_SUPPRESS_WARNING(4389) // 'operator' : signed/unsigned mismatch
1406
    DOCTEST_MSVC_SUPPRESS_WARNING(4018) // 'expression' : signed/unsigned mismatch
1407
    //DOCTEST_MSVC_SUPPRESS_WARNING(4805) // 'operation' : unsafe mix of type 'type' and type 'type' in operation
1408

1409
#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
1410

1411
    // clang-format off
1412
#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1413
#define DOCTEST_COMPARISON_RETURN_TYPE bool
1414
#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1415
#define DOCTEST_COMPARISON_RETURN_TYPE typename types::enable_if<can_use_op<L>::value || can_use_op<R>::value, bool>::type
1416
    inline bool eq(const char* lhs, const char* rhs) { return String(lhs) == String(rhs); }
1417
    inline bool ne(const char* lhs, const char* rhs) { return String(lhs) != String(rhs); }
1418
    inline bool lt(const char* lhs, const char* rhs) { return String(lhs) <  String(rhs); }
1419
    inline bool gt(const char* lhs, const char* rhs) { return String(lhs) >  String(rhs); }
1420
    inline bool le(const char* lhs, const char* rhs) { return String(lhs) <= String(rhs); }
1421
    inline bool ge(const char* lhs, const char* rhs) { return String(lhs) >= String(rhs); }
1422
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1423
    // clang-format on
1424

1425
#define DOCTEST_RELATIONAL_OP(name, op)                                                            \
1426
    template <typename L, typename R>                                                              \
1427
    DOCTEST_COMPARISON_RETURN_TYPE name(const DOCTEST_REF_WRAP(L) lhs,                             \
1428
                                        const DOCTEST_REF_WRAP(R) rhs) {                           \
1429
        return lhs op rhs;                                                                         \
1430
    }
1431

1432
    DOCTEST_RELATIONAL_OP(eq, ==)
1433
    DOCTEST_RELATIONAL_OP(ne, !=)
1434
    DOCTEST_RELATIONAL_OP(lt, <)
1435
    DOCTEST_RELATIONAL_OP(gt, >)
1436
    DOCTEST_RELATIONAL_OP(le, <=)
1437
    DOCTEST_RELATIONAL_OP(ge, >=)
1438

1439
#ifndef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1440
#define DOCTEST_CMP_EQ(l, r) l == r
1441
#define DOCTEST_CMP_NE(l, r) l != r
1442
#define DOCTEST_CMP_GT(l, r) l > r
1443
#define DOCTEST_CMP_LT(l, r) l < r
1444
#define DOCTEST_CMP_GE(l, r) l >= r
1445
#define DOCTEST_CMP_LE(l, r) l <= r
1446
#else // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1447
#define DOCTEST_CMP_EQ(l, r) eq(l, r)
1448
#define DOCTEST_CMP_NE(l, r) ne(l, r)
1449
#define DOCTEST_CMP_GT(l, r) gt(l, r)
1450
#define DOCTEST_CMP_LT(l, r) lt(l, r)
1451
#define DOCTEST_CMP_GE(l, r) ge(l, r)
1452
#define DOCTEST_CMP_LE(l, r) le(l, r)
1453
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
1454

1455
    template <typename L>
1456
    // cppcheck-suppress copyCtorAndEqOperator
1457
    struct Expression_lhs
1458
    {
1459
        L                lhs;
1460
        assertType::Enum m_at;
1461

1462
        explicit Expression_lhs(L&& in, assertType::Enum at)
1463
                : lhs(static_cast<L&&>(in))
1464
                , m_at(at) {}
1465

1466
        DOCTEST_NOINLINE operator Result() {
1467
// this is needed only for MSVC 2015
1468
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4800) // 'int': forcing value to bool
1469
            bool res = static_cast<bool>(lhs);
1470
DOCTEST_MSVC_SUPPRESS_WARNING_POP
1471
            if(m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
1472
                res = !res;
1473
            }
1474

1475
            if(!res || getContextOptions()->success) {
1476
                return { res, (DOCTEST_STRINGIFY(lhs)) };
1477
            }
1478
            return { res };
1479
        }
1480

1481
        /* This is required for user-defined conversions from Expression_lhs to L */
1482
        operator L() const { return lhs; }
1483

1484
        // clang-format off
1485
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(==, " == ", DOCTEST_CMP_EQ) //!OCLINT bitwise operator in conditional
1486
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(!=, " != ", DOCTEST_CMP_NE) //!OCLINT bitwise operator in conditional
1487
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>,  " >  ", DOCTEST_CMP_GT) //!OCLINT bitwise operator in conditional
1488
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<,  " <  ", DOCTEST_CMP_LT) //!OCLINT bitwise operator in conditional
1489
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(>=, " >= ", DOCTEST_CMP_GE) //!OCLINT bitwise operator in conditional
1490
        DOCTEST_DO_BINARY_EXPRESSION_COMPARISON(<=, " <= ", DOCTEST_CMP_LE) //!OCLINT bitwise operator in conditional
1491
        // clang-format on
1492

1493
        // forbidding some expressions based on this table: https://en.cppreference.com/w/cpp/language/operator_precedence
1494
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &)
1495
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^)
1496
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |)
1497
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &&)
1498
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ||)
1499
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, =)
1500
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, +=)
1501
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, -=)
1502
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, *=)
1503
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, /=)
1504
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, %=)
1505
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<=)
1506
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>=)
1507
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, &=)
1508
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, ^=)
1509
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, |=)
1510
        // these 2 are unfortunate because they should be allowed - they have higher precedence over the comparisons, but the
1511
        // ExpressionDecomposer class uses the left shift operator to capture the left operand of the binary expression...
1512
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, <<)
1513
        DOCTEST_FORBIT_EXPRESSION(Expression_lhs, >>)
1514
    };
1515

1516
#ifndef DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
1517

1518
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
1519
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
1520
    DOCTEST_GCC_SUPPRESS_WARNING_POP
1521

1522
#endif // DOCTEST_CONFIG_NO_COMPARISON_WARNING_SUPPRESSION
1523

1524
#if DOCTEST_CLANG && DOCTEST_CLANG < DOCTEST_COMPILER(3, 6, 0)
1525
DOCTEST_CLANG_SUPPRESS_WARNING_POP
1526
#endif
1527

1528
    struct DOCTEST_INTERFACE ExpressionDecomposer
1529
    {
1530
        assertType::Enum m_at;
1531

1532
        ExpressionDecomposer(assertType::Enum at);
1533

1534
        // The right operator for capturing expressions is "<=" instead of "<<" (based on the operator precedence table)
1535
        // but then there will be warnings from GCC about "-Wparentheses" and since "_Pragma()" is problematic this will stay for now...
1536
        // https://github.com/catchorg/Catch2/issues/870
1537
        // https://github.com/catchorg/Catch2/issues/565
1538
        template <typename L>
1539
        Expression_lhs<L> operator<<(L&& operand) {
1540
            return Expression_lhs<L>(static_cast<L&&>(operand), m_at);
1541
        }
1542

1543
        template <typename L,typename types::enable_if<!doctest::detail::types::is_rvalue_reference<L>::value,void >::type* = nullptr>
1544
        Expression_lhs<const L&> operator<<(const L &operand) {
1545
            return Expression_lhs<const L&>(operand, m_at);
1546
        }
1547
    };
1548

1549
    struct DOCTEST_INTERFACE TestSuite
1550
    {
1551
        const char* m_test_suite = nullptr;
1552
        const char* m_description = nullptr;
1553
        bool        m_skip = false;
1554
        bool        m_no_breaks = false;
1555
        bool        m_no_output = false;
1556
        bool        m_may_fail = false;
1557
        bool        m_should_fail = false;
1558
        int         m_expected_failures = 0;
1559
        double      m_timeout = 0;
1560

1561
        TestSuite& operator*(const char* in);
1562

1563
        template <typename T>
1564
        TestSuite& operator*(const T& in) {
1565
            in.fill(*this);
1566
            return *this;
1567
        }
1568
    };
1569

1570
    using funcType = void (*)();
1571

1572
    struct DOCTEST_INTERFACE TestCase : public TestCaseData
1573
    {
1574
        funcType m_test; // a function pointer to the test case
1575

1576
        String m_type; // for templated test cases - gets appended to the real name
1577
        int m_template_id; // an ID used to distinguish between the different versions of a templated test case
1578
        String m_full_name; // contains the name (only for templated test cases!) + the template type
1579

1580
        TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
1581
                 const String& type = String(), int template_id = -1);
1582

1583
        TestCase(const TestCase& other);
1584
        TestCase(TestCase&&) = delete;
1585

1586
        DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
1587
        TestCase& operator=(const TestCase& other);
1588
        DOCTEST_MSVC_SUPPRESS_WARNING_POP
1589

1590
        TestCase& operator=(TestCase&&) = delete;
1591

1592
        TestCase& operator*(const char* in);
1593

1594
        template <typename T>
1595
        TestCase& operator*(const T& in) {
1596
            in.fill(*this);
1597
            return *this;
1598
        }
1599

1600
        bool operator<(const TestCase& other) const;
1601

1602
        ~TestCase() = default;
1603
    };
1604

1605
    // forward declarations of functions used by the macros
1606
    DOCTEST_INTERFACE int  regTest(const TestCase& tc);
1607
    DOCTEST_INTERFACE int  setTestSuite(const TestSuite& ts);
1608
    DOCTEST_INTERFACE bool isDebuggerActive();
1609

1610
    template<typename T>
1611
    int instantiationHelper(const T&) { return 0; }
1612

1613
    namespace binaryAssertComparison {
1614
        enum Enum
1615
        {
1616
            eq = 0,
1617
            ne,
1618
            gt,
1619
            lt,
1620
            ge,
1621
            le
1622
        };
1623
    } // namespace binaryAssertComparison
1624

1625
    // clang-format off
1626
    template <int, class L, class R> struct RelationalComparator     { bool operator()(const DOCTEST_REF_WRAP(L),     const DOCTEST_REF_WRAP(R)    ) const { return false;        } };
1627

1628
#define DOCTEST_BINARY_RELATIONAL_OP(n, op) \
1629
    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); } };
1630
    // clang-format on
1631

1632
    DOCTEST_BINARY_RELATIONAL_OP(0, doctest::detail::eq)
1633
    DOCTEST_BINARY_RELATIONAL_OP(1, doctest::detail::ne)
1634
    DOCTEST_BINARY_RELATIONAL_OP(2, doctest::detail::gt)
1635
    DOCTEST_BINARY_RELATIONAL_OP(3, doctest::detail::lt)
1636
    DOCTEST_BINARY_RELATIONAL_OP(4, doctest::detail::ge)
1637
    DOCTEST_BINARY_RELATIONAL_OP(5, doctest::detail::le)
1638

1639
    struct DOCTEST_INTERFACE ResultBuilder : public AssertData
1640
    {
1641
        ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
1642
                      const char* exception_type = "", const String& exception_string = "");
1643

1644
        ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
1645
                      const char* exception_type, const Contains& exception_string);
1646

1647
        void setResult(const Result& res);
1648

1649
        template <int comparison, typename L, typename R>
1650
        DOCTEST_NOINLINE bool binary_assert(const DOCTEST_REF_WRAP(L) lhs,
1651
                                            const DOCTEST_REF_WRAP(R) rhs) {
1652
            m_failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
1653
            if (m_failed || getContextOptions()->success) {
1654
                m_decomp = stringifyBinaryExpr(lhs, ", ", rhs);
1655
            }
1656
            return !m_failed;
1657
        }
1658

1659
        template <typename L>
1660
        DOCTEST_NOINLINE bool unary_assert(const DOCTEST_REF_WRAP(L) val) {
1661
            m_failed = !val;
1662

1663
            if (m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
1664
                m_failed = !m_failed;
1665
            }
1666

1667
            if (m_failed || getContextOptions()->success) {
1668
                m_decomp = (DOCTEST_STRINGIFY(val));
1669
            }
1670

1671
            return !m_failed;
1672
        }
1673

1674
        void translateException();
1675

1676
        bool log();
1677
        void react() const;
1678
    };
1679

1680
    namespace assertAction {
1681
        enum Enum
1682
        {
1683
            nothing     = 0,
1684
            dbgbreak    = 1,
1685
            shouldthrow = 2
1686
        };
1687
    } // namespace assertAction
1688

1689
    DOCTEST_INTERFACE void failed_out_of_a_testing_context(const AssertData& ad);
1690

1691
    DOCTEST_INTERFACE bool decomp_assert(assertType::Enum at, const char* file, int line,
1692
                                         const char* expr, const Result& result);
1693

1694
#define DOCTEST_ASSERT_OUT_OF_TESTS(decomp)                                                        \
1695
    do {                                                                                           \
1696
        if(!is_running_in_test) {                                                                  \
1697
            if(failed) {                                                                           \
1698
                ResultBuilder rb(at, file, line, expr);                                            \
1699
                rb.m_failed = failed;                                                              \
1700
                rb.m_decomp = decomp;                                                              \
1701
                failed_out_of_a_testing_context(rb);                                               \
1702
                if(isDebuggerActive() && !getContextOptions()->no_breaks)                          \
1703
                    DOCTEST_BREAK_INTO_DEBUGGER();                                                 \
1704
                if(checkIfShouldThrow(at))                                                         \
1705
                    throwException();                                                              \
1706
            }                                                                                      \
1707
            return !failed;                                                                        \
1708
        }                                                                                          \
1709
    } while(false)
1710

1711
#define DOCTEST_ASSERT_IN_TESTS(decomp)                                                            \
1712
    ResultBuilder rb(at, file, line, expr);                                                        \
1713
    rb.m_failed = failed;                                                                          \
1714
    if(rb.m_failed || getContextOptions()->success)                                                \
1715
        rb.m_decomp = decomp;                                                                      \
1716
    if(rb.log())                                                                                   \
1717
        DOCTEST_BREAK_INTO_DEBUGGER();                                                             \
1718
    if(rb.m_failed && checkIfShouldThrow(at))                                                      \
1719
    throwException()
1720

1721
    template <int comparison, typename L, typename R>
1722
    DOCTEST_NOINLINE bool binary_assert(assertType::Enum at, const char* file, int line,
1723
                                        const char* expr, const DOCTEST_REF_WRAP(L) lhs,
1724
                                        const DOCTEST_REF_WRAP(R) rhs) {
1725
        bool failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
1726

1727
        // ###################################################################################
1728
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
1729
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
1730
        // ###################################################################################
1731
        DOCTEST_ASSERT_OUT_OF_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
1732
        DOCTEST_ASSERT_IN_TESTS(stringifyBinaryExpr(lhs, ", ", rhs));
1733
        return !failed;
1734
    }
1735

1736
    template <typename L>
1737
    DOCTEST_NOINLINE bool unary_assert(assertType::Enum at, const char* file, int line,
1738
                                       const char* expr, const DOCTEST_REF_WRAP(L) val) {
1739
        bool failed = !val;
1740

1741
        if(at & assertType::is_false) //!OCLINT bitwise operator in conditional
1742
            failed = !failed;
1743

1744
        // ###################################################################################
1745
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
1746
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
1747
        // ###################################################################################
1748
        DOCTEST_ASSERT_OUT_OF_TESTS((DOCTEST_STRINGIFY(val)));
1749
        DOCTEST_ASSERT_IN_TESTS((DOCTEST_STRINGIFY(val)));
1750
        return !failed;
1751
    }
1752

1753
    struct DOCTEST_INTERFACE IExceptionTranslator
1754
    {
1755
        DOCTEST_DECLARE_INTERFACE(IExceptionTranslator)
1756
        virtual bool translate(String&) const = 0;
1757
    };
1758

1759
    template <typename T>
1760
    class ExceptionTranslator : public IExceptionTranslator //!OCLINT destructor of virtual class
1761
    {
1762
    public:
1763
        explicit ExceptionTranslator(String (*translateFunction)(T))
1764
                : m_translateFunction(translateFunction) {}
1765

1766
        bool translate(String& res) const override {
1767
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
1768
            try {
1769
                throw; // lgtm [cpp/rethrow-no-exception]
1770
                // cppcheck-suppress catchExceptionByValue
1771
            } catch(const T& ex) {
1772
                res = m_translateFunction(ex); //!OCLINT parameter reassignment
1773
                return true;
1774
            } catch(...) {}         //!OCLINT -  empty catch statement
1775
#endif                              // DOCTEST_CONFIG_NO_EXCEPTIONS
1776
            static_cast<void>(res); // to silence -Wunused-parameter
1777
            return false;
1778
        }
1779

1780
    private:
1781
        String (*m_translateFunction)(T);
1782
    };
1783

1784
    DOCTEST_INTERFACE void registerExceptionTranslatorImpl(const IExceptionTranslator* et);
1785

1786
    // ContextScope base class used to allow implementing methods of ContextScope
1787
    // that don't depend on the template parameter in doctest.cpp.
1788
    struct DOCTEST_INTERFACE ContextScopeBase : public IContextScope {
1789
        ContextScopeBase(const ContextScopeBase&) = delete;
1790

1791
        ContextScopeBase& operator=(const ContextScopeBase&) = delete;
1792
        ContextScopeBase& operator=(ContextScopeBase&&) = delete;
1793

1794
        ~ContextScopeBase() override = default;
1795

1796
    protected:
1797
        ContextScopeBase();
1798
        ContextScopeBase(ContextScopeBase&& other) noexcept;
1799

1800
        void destroy();
1801
        bool need_to_destroy{true};
1802
    };
1803

1804
    template <typename L> class ContextScope : public ContextScopeBase
1805
    {
1806
        L lambda_;
1807

1808
    public:
1809
        explicit ContextScope(const L &lambda) : lambda_(lambda) {}
1810
        explicit ContextScope(L&& lambda) : lambda_(static_cast<L&&>(lambda)) { }
1811

1812
        ContextScope(const ContextScope&) = delete;
1813
        ContextScope(ContextScope&&) noexcept = default;
1814

1815
        ContextScope& operator=(const ContextScope&) = delete;
1816
        ContextScope& operator=(ContextScope&&) = delete;
1817

1818
        void stringify(std::ostream* s) const override { lambda_(s); }
1819

1820
        ~ContextScope() override {
1821
            if (need_to_destroy) {
1822
                destroy();
1823
            }
1824
        }
1825
    };
1826

1827
    struct DOCTEST_INTERFACE MessageBuilder : public MessageData
1828
    {
1829
        std::ostream* m_stream;
1830
        bool          logged = false;
1831

1832
        MessageBuilder(const char* file, int line, assertType::Enum severity);
1833

1834
        MessageBuilder(const MessageBuilder&) = delete;
1835
        MessageBuilder(MessageBuilder&&) = delete;
1836

1837
        MessageBuilder& operator=(const MessageBuilder&) = delete;
1838
        MessageBuilder& operator=(MessageBuilder&&) = delete;
1839

1840
        ~MessageBuilder();
1841

1842
        // the preferred way of chaining parameters for stringification
1843
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4866)
1844
        template <typename T>
1845
        MessageBuilder& operator,(const T& in) {
1846
            *m_stream << (DOCTEST_STRINGIFY(in));
1847
            return *this;
1848
        }
1849
DOCTEST_MSVC_SUPPRESS_WARNING_POP
1850

1851
        // kept here just for backwards-compatibility - the comma operator should be preferred now
1852
        template <typename T>
1853
        MessageBuilder& operator<<(const T& in) { return this->operator,(in); }
1854

1855
        // the `,` operator has the lowest operator precedence - if `<<` is used by the user then
1856
        // the `,` operator will be called last which is not what we want and thus the `*` operator
1857
        // is used first (has higher operator precedence compared to `<<`) so that we guarantee that
1858
        // an operator of the MessageBuilder class is called first before the rest of the parameters
1859
        template <typename T>
1860
        MessageBuilder& operator*(const T& in) { return this->operator,(in); }
1861

1862
        bool log();
1863
        void react();
1864
    };
1865

1866
    template <typename L>
1867
    ContextScope<L> MakeContextScope(const L &lambda) {
1868
        return ContextScope<L>(lambda);
1869
    }
1870
} // namespace detail
1871

1872
#define DOCTEST_DEFINE_DECORATOR(name, type, def)                                                  \
1873
    struct name                                                                                    \
1874
    {                                                                                              \
1875
        type data;                                                                                 \
1876
        name(type in = def)                                                                        \
1877
                : data(in) {}                                                                      \
1878
        void fill(detail::TestCase& state) const { state.DOCTEST_CAT(m_, name) = data; }           \
1879
        void fill(detail::TestSuite& state) const { state.DOCTEST_CAT(m_, name) = data; }          \
1880
    }
1881

1882
DOCTEST_DEFINE_DECORATOR(test_suite, const char*, "");
1883
DOCTEST_DEFINE_DECORATOR(description, const char*, "");
1884
DOCTEST_DEFINE_DECORATOR(skip, bool, true);
1885
DOCTEST_DEFINE_DECORATOR(no_breaks, bool, true);
1886
DOCTEST_DEFINE_DECORATOR(no_output, bool, true);
1887
DOCTEST_DEFINE_DECORATOR(timeout, double, 0);
1888
DOCTEST_DEFINE_DECORATOR(may_fail, bool, true);
1889
DOCTEST_DEFINE_DECORATOR(should_fail, bool, true);
1890
DOCTEST_DEFINE_DECORATOR(expected_failures, int, 0);
1891

1892
template <typename T>
1893
int registerExceptionTranslator(String (*translateFunction)(T)) {
1894
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors")
1895
    static detail::ExceptionTranslator<T> exceptionTranslator(translateFunction);
1896
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
1897
    detail::registerExceptionTranslatorImpl(&exceptionTranslator);
1898
    return 0;
1899
}
1900

1901
} // namespace doctest
1902

1903
// in a separate namespace outside of doctest because the DOCTEST_TEST_SUITE macro
1904
// introduces an anonymous namespace in which getCurrentTestSuite gets overridden
1905
namespace doctest_detail_test_suite_ns {
1906
DOCTEST_INTERFACE doctest::detail::TestSuite& getCurrentTestSuite();
1907
} // namespace doctest_detail_test_suite_ns
1908

1909
namespace doctest {
1910
#else  // DOCTEST_CONFIG_DISABLE
1911
template <typename T>
1912
int registerExceptionTranslator(String (*)(T)) {
1913
    return 0;
1914
}
1915
#endif // DOCTEST_CONFIG_DISABLE
1916

1917
namespace detail {
1918
    using assert_handler = void (*)(const AssertData&);
1919
    struct ContextState;
1920
} // namespace detail
1921

1922
class DOCTEST_INTERFACE Context
1923
{
1924
    detail::ContextState* p;
1925

1926
    void parseArgs(int argc, const char* const* argv, bool withDefaults = false);
1927

1928
public:
1929
    explicit Context(int argc = 0, const char* const* argv = nullptr);
1930

1931
    Context(const Context&) = delete;
1932
    Context(Context&&) = delete;
1933

1934
    Context& operator=(const Context&) = delete;
1935
    Context& operator=(Context&&) = delete;
1936

1937
    ~Context(); // NOLINT(performance-trivially-destructible)
1938

1939
    void applyCommandLine(int argc, const char* const* argv);
1940

1941
    void addFilter(const char* filter, const char* value);
1942
    void clearFilters();
1943
    void setOption(const char* option, bool value);
1944
    void setOption(const char* option, int value);
1945
    void setOption(const char* option, const char* value);
1946

1947
    bool shouldExit();
1948

1949
    void setAsDefaultForAssertsOutOfTestCases();
1950

1951
    void setAssertHandler(detail::assert_handler ah);
1952

1953
    void setCout(std::ostream* out);
1954

1955
    int run();
1956
};
1957

1958
namespace TestCaseFailureReason {
1959
    enum Enum
1960
    {
1961
        None                     = 0,
1962
        AssertFailure            = 1,   // an assertion has failed in the test case
1963
        Exception                = 2,   // test case threw an exception
1964
        Crash                    = 4,   // a crash...
1965
        TooManyFailedAsserts     = 8,   // the abort-after option
1966
        Timeout                  = 16,  // see the timeout decorator
1967
        ShouldHaveFailedButDidnt = 32,  // see the should_fail decorator
1968
        ShouldHaveFailedAndDid   = 64,  // see the should_fail decorator
1969
        DidntFailExactlyNumTimes = 128, // see the expected_failures decorator
1970
        FailedExactlyNumTimes    = 256, // see the expected_failures decorator
1971
        CouldHaveFailedAndDid    = 512  // see the may_fail decorator
1972
    };
1973
} // namespace TestCaseFailureReason
1974

1975
struct DOCTEST_INTERFACE CurrentTestCaseStats
1976
{
1977
    int    numAssertsCurrentTest;
1978
    int    numAssertsFailedCurrentTest;
1979
    double seconds;
1980
    int    failure_flags; // use TestCaseFailureReason::Enum
1981
    bool   testCaseSuccess;
1982
};
1983

1984
struct DOCTEST_INTERFACE TestCaseException
1985
{
1986
    String error_string;
1987
    bool   is_crash;
1988
};
1989

1990
struct DOCTEST_INTERFACE TestRunStats
1991
{
1992
    unsigned numTestCases;
1993
    unsigned numTestCasesPassingFilters;
1994
    unsigned numTestSuitesPassingFilters;
1995
    unsigned numTestCasesFailed;
1996
    int      numAsserts;
1997
    int      numAssertsFailed;
1998
};
1999

2000
struct QueryData
2001
{
2002
    const TestRunStats*  run_stats = nullptr;
2003
    const TestCaseData** data      = nullptr;
2004
    unsigned             num_data  = 0;
2005
};
2006

2007
struct DOCTEST_INTERFACE IReporter
2008
{
2009
    // The constructor has to accept "const ContextOptions&" as a single argument
2010
    // which has most of the options for the run + a pointer to the stdout stream
2011
    // Reporter(const ContextOptions& in)
2012

2013
    // called when a query should be reported (listing test cases, printing the version, etc.)
2014
    virtual void report_query(const QueryData&) = 0;
2015

2016
    // called when the whole test run starts
2017
    virtual void test_run_start() = 0;
2018
    // called when the whole test run ends (caching a pointer to the input doesn't make sense here)
2019
    virtual void test_run_end(const TestRunStats&) = 0;
2020

2021
    // called when a test case is started (safe to cache a pointer to the input)
2022
    virtual void test_case_start(const TestCaseData&) = 0;
2023
    // called when a test case is reentered because of unfinished subcases (safe to cache a pointer to the input)
2024
    virtual void test_case_reenter(const TestCaseData&) = 0;
2025
    // called when a test case has ended
2026
    virtual void test_case_end(const CurrentTestCaseStats&) = 0;
2027

2028
    // called when an exception is thrown from the test case (or it crashes)
2029
    virtual void test_case_exception(const TestCaseException&) = 0;
2030

2031
    // called whenever a subcase is entered (don't cache pointers to the input)
2032
    virtual void subcase_start(const SubcaseSignature&) = 0;
2033
    // called whenever a subcase is exited (don't cache pointers to the input)
2034
    virtual void subcase_end() = 0;
2035

2036
    // called for each assert (don't cache pointers to the input)
2037
    virtual void log_assert(const AssertData&) = 0;
2038
    // called for each message (don't cache pointers to the input)
2039
    virtual void log_message(const MessageData&) = 0;
2040

2041
    // called when a test case is skipped either because it doesn't pass the filters, has a skip decorator
2042
    // or isn't in the execution range (between first and last) (safe to cache a pointer to the input)
2043
    virtual void test_case_skipped(const TestCaseData&) = 0;
2044

2045
    DOCTEST_DECLARE_INTERFACE(IReporter)
2046

2047
    // can obtain all currently active contexts and stringify them if one wishes to do so
2048
    static int                         get_num_active_contexts();
2049
    static const IContextScope* const* get_active_contexts();
2050

2051
    // can iterate through contexts which have been stringified automatically in their destructors when an exception has been thrown
2052
    static int           get_num_stringified_contexts();
2053
    static const String* get_stringified_contexts();
2054
};
2055

2056
namespace detail {
2057
    using reporterCreatorFunc =  IReporter* (*)(const ContextOptions&);
2058

2059
    DOCTEST_INTERFACE void registerReporterImpl(const char* name, int prio, reporterCreatorFunc c, bool isReporter);
2060

2061
    template <typename Reporter>
2062
    IReporter* reporterCreator(const ContextOptions& o) {
2063
        return new Reporter(o);
2064
    }
2065
} // namespace detail
2066

2067
template <typename Reporter>
2068
int registerReporter(const char* name, int priority, bool isReporter) {
2069
    detail::registerReporterImpl(name, priority, detail::reporterCreator<Reporter>, isReporter);
2070
    return 0;
2071
}
2072
} // namespace doctest
2073

2074
#ifdef DOCTEST_CONFIG_ASSERTS_RETURN_VALUES
2075
#define DOCTEST_FUNC_EMPTY [] { return false; }()
2076
#else
2077
#define DOCTEST_FUNC_EMPTY (void)0
2078
#endif
2079

2080
// if registering is not disabled
2081
#ifndef DOCTEST_CONFIG_DISABLE
2082

2083
#ifdef DOCTEST_CONFIG_ASSERTS_RETURN_VALUES
2084
#define DOCTEST_FUNC_SCOPE_BEGIN [&]
2085
#define DOCTEST_FUNC_SCOPE_END ()
2086
#define DOCTEST_FUNC_SCOPE_RET(v) return v
2087
#else
2088
#define DOCTEST_FUNC_SCOPE_BEGIN do
2089
#define DOCTEST_FUNC_SCOPE_END while(false)
2090
#define DOCTEST_FUNC_SCOPE_RET(v) (void)0
2091
#endif
2092

2093
// common code in asserts - for convenience
2094
#define DOCTEST_ASSERT_LOG_REACT_RETURN(b)                                                         \
2095
    if(b.log()) DOCTEST_BREAK_INTO_DEBUGGER();                                                     \
2096
    b.react();                                                                                     \
2097
    DOCTEST_FUNC_SCOPE_RET(!b.m_failed)
2098

2099
#ifdef DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
2100
#define DOCTEST_WRAP_IN_TRY(x) x;
2101
#else // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
2102
#define DOCTEST_WRAP_IN_TRY(x)                                                                     \
2103
    try {                                                                                          \
2104
        x;                                                                                         \
2105
    } catch(...) { DOCTEST_RB.translateException(); }
2106
#endif // DOCTEST_CONFIG_NO_TRY_CATCH_IN_ASSERTS
2107

2108
#ifdef DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
2109
#define DOCTEST_CAST_TO_VOID(...)                                                                  \
2110
    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wuseless-cast")                                       \
2111
    static_cast<void>(__VA_ARGS__);                                                                \
2112
    DOCTEST_GCC_SUPPRESS_WARNING_POP
2113
#else // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
2114
#define DOCTEST_CAST_TO_VOID(...) __VA_ARGS__;
2115
#endif // DOCTEST_CONFIG_VOID_CAST_EXPRESSIONS
2116

2117
// registers the test by initializing a dummy var with a function
2118
#define DOCTEST_REGISTER_FUNCTION(global_prefix, f, decorators)                                    \
2119
    global_prefix DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT */    \
2120
            doctest::detail::regTest(                                                              \
2121
                    doctest::detail::TestCase(                                                     \
2122
                            f, __FILE__, __LINE__,                                                 \
2123
                            doctest_detail_test_suite_ns::getCurrentTestSuite()) *                 \
2124
                    decorators))
2125

2126
#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, decorators)                                     \
2127
    namespace { /* NOLINT */                                                                       \
2128
        struct der : public base                                                                   \
2129
        {                                                                                          \
2130
            void f();                                                                              \
2131
        };                                                                                         \
2132
        static inline DOCTEST_NOINLINE void func() {                                               \
2133
            der v;                                                                                 \
2134
            v.f();                                                                                 \
2135
        }                                                                                          \
2136
        DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, func, decorators)                                 \
2137
    }                                                                                              \
2138
    inline DOCTEST_NOINLINE void der::f() // NOLINT(misc-definitions-in-headers)
2139

2140
#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, decorators)                                        \
2141
    static void f();                                                                               \
2142
    DOCTEST_REGISTER_FUNCTION(DOCTEST_EMPTY, f, decorators)                                        \
2143
    static void f()
2144

2145
#define DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(f, proxy, decorators)                        \
2146
    static doctest::detail::funcType proxy() { return f; }                                         \
2147
    DOCTEST_REGISTER_FUNCTION(inline, proxy(), decorators)                                         \
2148
    static void f()
2149

2150
// for registering tests
2151
#define DOCTEST_TEST_CASE(decorators)                                                              \
2152
    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), decorators)
2153

2154
// for registering tests in classes - requires C++17 for inline variables!
2155
#if DOCTEST_CPLUSPLUS >= 201703L
2156
#define DOCTEST_TEST_CASE_CLASS(decorators)                                                        \
2157
    DOCTEST_CREATE_AND_REGISTER_FUNCTION_IN_CLASS(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_),           \
2158
                                                  DOCTEST_ANONYMOUS(DOCTEST_ANON_PROXY_),          \
2159
                                                  decorators)
2160
#else // DOCTEST_TEST_CASE_CLASS
2161
#define DOCTEST_TEST_CASE_CLASS(...)                                                               \
2162
    TEST_CASES_CAN_BE_REGISTERED_IN_CLASSES_ONLY_IN_CPP17_MODE_OR_WITH_VS_2017_OR_NEWER
2163
#endif // DOCTEST_TEST_CASE_CLASS
2164

2165
// for registering tests with a fixture
2166
#define DOCTEST_TEST_CASE_FIXTURE(c, decorators)                                                   \
2167
    DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(DOCTEST_ANON_CLASS_), c,                           \
2168
                              DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), decorators)
2169

2170
// for converting types to strings without the <typeinfo> header and demangling
2171
#define DOCTEST_TYPE_TO_STRING_AS(str, ...)                                                        \
2172
    namespace doctest {                                                                            \
2173
        template <>                                                                                \
2174
        inline String toString<__VA_ARGS__>() {                                                    \
2175
            return str;                                                                            \
2176
        }                                                                                          \
2177
    }                                                                                              \
2178
    static_assert(true, "")
2179

2180
#define DOCTEST_TYPE_TO_STRING(...) DOCTEST_TYPE_TO_STRING_AS(#__VA_ARGS__, __VA_ARGS__)
2181

2182
#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, iter, func)                                 \
2183
    template <typename T>                                                                          \
2184
    static void func();                                                                            \
2185
    namespace { /* NOLINT */                                                                       \
2186
        template <typename Tuple>                                                                  \
2187
        struct iter;                                                                               \
2188
        template <typename Type, typename... Rest>                                                 \
2189
        struct iter<std::tuple<Type, Rest...>>                                                     \
2190
        {                                                                                          \
2191
            iter(const char* file, unsigned line, int index) {                                     \
2192
                doctest::detail::regTest(doctest::detail::TestCase(func<Type>, file, line,         \
2193
                                            doctest_detail_test_suite_ns::getCurrentTestSuite(),   \
2194
                                            doctest::toString<Type>(),                             \
2195
                                            int(line) * 1000 + index)                              \
2196
                                         * dec);                                                   \
2197
                iter<std::tuple<Rest...>>(file, line, index + 1);                                  \
2198
            }                                                                                      \
2199
        };                                                                                         \
2200
        template <>                                                                                \
2201
        struct iter<std::tuple<>>                                                                  \
2202
        {                                                                                          \
2203
            iter(const char*, unsigned, int) {}                                                    \
2204
        };                                                                                         \
2205
    }                                                                                              \
2206
    template <typename T>                                                                          \
2207
    static void func()
2208

2209
#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(dec, T, id)                                              \
2210
    DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(id, ITERATOR),                      \
2211
                                           DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_))
2212

2213
#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, anon, ...)                                 \
2214
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_CAT(anon, DUMMY), /* NOLINT(cert-err58-cpp, fuchsia-statically-constructed-objects) */ \
2215
        doctest::detail::instantiationHelper(                                                      \
2216
            DOCTEST_CAT(id, ITERATOR)<__VA_ARGS__>(__FILE__, __LINE__, 0)))
2217

2218
#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...)                                                 \
2219
    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), std::tuple<__VA_ARGS__>) \
2220
    static_assert(true, "")
2221

2222
#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...)                                                  \
2223
    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(id, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), __VA_ARGS__) \
2224
    static_assert(true, "")
2225

2226
#define DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, anon, ...)                                         \
2227
    DOCTEST_TEST_CASE_TEMPLATE_DEFINE_IMPL(dec, T, DOCTEST_CAT(anon, ITERATOR), anon);             \
2228
    DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE_IMPL(anon, anon, std::tuple<__VA_ARGS__>)               \
2229
    template <typename T>                                                                          \
2230
    static void anon()
2231

2232
#define DOCTEST_TEST_CASE_TEMPLATE(dec, T, ...)                                                    \
2233
    DOCTEST_TEST_CASE_TEMPLATE_IMPL(dec, T, DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_), __VA_ARGS__)
2234

2235
// for subcases
2236
#define DOCTEST_SUBCASE(name)                                                                      \
2237
    if(const doctest::detail::Subcase & DOCTEST_ANONYMOUS(DOCTEST_ANON_SUBCASE_) DOCTEST_UNUSED =  \
2238
               doctest::detail::Subcase(name, __FILE__, __LINE__))
2239

2240
// for grouping tests in test suites by using code blocks
2241
#define DOCTEST_TEST_SUITE_IMPL(decorators, ns_name)                                               \
2242
    namespace ns_name { namespace doctest_detail_test_suite_ns {                                   \
2243
            static DOCTEST_NOINLINE doctest::detail::TestSuite& getCurrentTestSuite() noexcept {   \
2244
                DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4640)                                      \
2245
                DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wexit-time-destructors")                \
2246
                DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmissing-field-initializers")             \
2247
                static doctest::detail::TestSuite data{};                                          \
2248
                static bool                       inited = false;                                  \
2249
                DOCTEST_MSVC_SUPPRESS_WARNING_POP                                                  \
2250
                DOCTEST_CLANG_SUPPRESS_WARNING_POP                                                 \
2251
                DOCTEST_GCC_SUPPRESS_WARNING_POP                                                   \
2252
                if(!inited) {                                                                      \
2253
                    data* decorators;                                                              \
2254
                    inited = true;                                                                 \
2255
                }                                                                                  \
2256
                return data;                                                                       \
2257
            }                                                                                      \
2258
        }                                                                                          \
2259
    }                                                                                              \
2260
    namespace ns_name
2261

2262
#define DOCTEST_TEST_SUITE(decorators)                                                             \
2263
    DOCTEST_TEST_SUITE_IMPL(decorators, DOCTEST_ANONYMOUS(DOCTEST_ANON_SUITE_))
2264

2265
// for starting a testsuite block
2266
#define DOCTEST_TEST_SUITE_BEGIN(decorators)                                                       \
2267
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT(cert-err58-cpp) */  \
2268
            doctest::detail::setTestSuite(doctest::detail::TestSuite() * decorators))              \
2269
    static_assert(true, "")
2270

2271
// for ending a testsuite block
2272
#define DOCTEST_TEST_SUITE_END                                                                     \
2273
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_VAR_), /* NOLINT(cert-err58-cpp) */  \
2274
            doctest::detail::setTestSuite(doctest::detail::TestSuite() * ""))                      \
2275
    using DOCTEST_ANONYMOUS(DOCTEST_ANON_FOR_SEMICOLON_) = int
2276

2277
// for registering exception translators
2278
#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(translatorName, signature)                      \
2279
    inline doctest::String translatorName(signature);                                              \
2280
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_), /* NOLINT(cert-err58-cpp) */ \
2281
            doctest::registerExceptionTranslator(translatorName))                                  \
2282
    doctest::String translatorName(signature)
2283

2284
#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)                                           \
2285
    DOCTEST_REGISTER_EXCEPTION_TRANSLATOR_IMPL(DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_),        \
2286
                                               signature)
2287

2288
// for registering reporters
2289
#define DOCTEST_REGISTER_REPORTER(name, priority, reporter)                                        \
2290
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_REPORTER_), /* NOLINT(cert-err58-cpp) */ \
2291
            doctest::registerReporter<reporter>(name, priority, true))                             \
2292
    static_assert(true, "")
2293

2294
// for registering listeners
2295
#define DOCTEST_REGISTER_LISTENER(name, priority, reporter)                                        \
2296
    DOCTEST_GLOBAL_NO_WARNINGS(DOCTEST_ANONYMOUS(DOCTEST_ANON_REPORTER_), /* NOLINT(cert-err58-cpp) */ \
2297
            doctest::registerReporter<reporter>(name, priority, false))                            \
2298
    static_assert(true, "")
2299

2300
// clang-format off
2301
// for logging - disabling formatting because it's important to have these on 2 separate lines - see PR #557
2302
#define DOCTEST_INFO(...)                                                                          \
2303
    DOCTEST_INFO_IMPL(DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_),                                         \
2304
                      DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_OTHER_),                                   \
2305
                      __VA_ARGS__)
2306
// clang-format on
2307

2308
#define DOCTEST_INFO_IMPL(mb_name, s_name, ...)                                       \
2309
    auto DOCTEST_ANONYMOUS(DOCTEST_CAPTURE_) = doctest::detail::MakeContextScope(                  \
2310
        [&](std::ostream* s_name) {                                                                \
2311
        doctest::detail::MessageBuilder mb_name(__FILE__, __LINE__, doctest::assertType::is_warn); \
2312
        mb_name.m_stream = s_name;                                                                 \
2313
        mb_name * __VA_ARGS__;                                                                     \
2314
    })
2315

2316
#define DOCTEST_CAPTURE(x) DOCTEST_INFO(#x " := ", x)
2317

2318
#define DOCTEST_ADD_AT_IMPL(type, file, line, mb, ...)                                             \
2319
    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
2320
        doctest::detail::MessageBuilder mb(file, line, doctest::assertType::type);                 \
2321
        mb * __VA_ARGS__;                                                                          \
2322
        if(mb.log())                                                                               \
2323
            DOCTEST_BREAK_INTO_DEBUGGER();                                                         \
2324
        mb.react();                                                                                \
2325
    } DOCTEST_FUNC_SCOPE_END
2326

2327
// clang-format off
2328
#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_warn, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
2329
#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_check, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
2330
#define DOCTEST_ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_AT_IMPL(is_require, file, line, DOCTEST_ANONYMOUS(DOCTEST_MESSAGE_), __VA_ARGS__)
2331
// clang-format on
2332

2333
#define DOCTEST_MESSAGE(...) DOCTEST_ADD_MESSAGE_AT(__FILE__, __LINE__, __VA_ARGS__)
2334
#define DOCTEST_FAIL_CHECK(...) DOCTEST_ADD_FAIL_CHECK_AT(__FILE__, __LINE__, __VA_ARGS__)
2335
#define DOCTEST_FAIL(...) DOCTEST_ADD_FAIL_AT(__FILE__, __LINE__, __VA_ARGS__)
2336

2337
#define DOCTEST_TO_LVALUE(...) __VA_ARGS__ // Not removed to keep backwards compatibility.
2338

2339
#ifndef DOCTEST_CONFIG_SUPER_FAST_ASSERTS
2340

2341
#define DOCTEST_ASSERT_IMPLEMENT_2(assert_type, ...)                                               \
2342
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses")                  \
2343
    /* NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) */                                  \
2344
    doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,          \
2345
                                               __LINE__, #__VA_ARGS__);                            \
2346
    DOCTEST_WRAP_IN_TRY(DOCTEST_RB.setResult(                                                      \
2347
            doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type)                \
2348
            << __VA_ARGS__)) /* NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) */         \
2349
    DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB)                                                    \
2350
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
2351

2352
#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...)                                               \
2353
    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
2354
        DOCTEST_ASSERT_IMPLEMENT_2(assert_type, __VA_ARGS__);                                      \
2355
    } DOCTEST_FUNC_SCOPE_END // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
2356

2357
#define DOCTEST_BINARY_ASSERT(assert_type, comp, ...)                                              \
2358
    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
2359
        doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,      \
2360
                                                   __LINE__, #__VA_ARGS__);                        \
2361
        DOCTEST_WRAP_IN_TRY(                                                                       \
2362
                DOCTEST_RB.binary_assert<doctest::detail::binaryAssertComparison::comp>(           \
2363
                        __VA_ARGS__))                                                              \
2364
        DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                               \
2365
    } DOCTEST_FUNC_SCOPE_END
2366

2367
#define DOCTEST_UNARY_ASSERT(assert_type, ...)                                                     \
2368
    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
2369
        doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,      \
2370
                                                   __LINE__, #__VA_ARGS__);                        \
2371
        DOCTEST_WRAP_IN_TRY(DOCTEST_RB.unary_assert(__VA_ARGS__))                                  \
2372
        DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                               \
2373
    } DOCTEST_FUNC_SCOPE_END
2374

2375
#else // DOCTEST_CONFIG_SUPER_FAST_ASSERTS
2376

2377
// necessary for <ASSERT>_MESSAGE
2378
#define DOCTEST_ASSERT_IMPLEMENT_2 DOCTEST_ASSERT_IMPLEMENT_1
2379

2380
#define DOCTEST_ASSERT_IMPLEMENT_1(assert_type, ...)                                               \
2381
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Woverloaded-shift-op-parentheses")                  \
2382
    doctest::detail::decomp_assert(                                                                \
2383
            doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__,                    \
2384
            doctest::detail::ExpressionDecomposer(doctest::assertType::assert_type)                \
2385
                    << __VA_ARGS__) DOCTEST_CLANG_SUPPRESS_WARNING_POP
2386

2387
#define DOCTEST_BINARY_ASSERT(assert_type, comparison, ...)                                        \
2388
    doctest::detail::binary_assert<doctest::detail::binaryAssertComparison::comparison>(           \
2389
            doctest::assertType::assert_type, __FILE__, __LINE__, #__VA_ARGS__, __VA_ARGS__)
2390

2391
#define DOCTEST_UNARY_ASSERT(assert_type, ...)                                                     \
2392
    doctest::detail::unary_assert(doctest::assertType::assert_type, __FILE__, __LINE__,            \
2393
                                  #__VA_ARGS__, __VA_ARGS__)
2394

2395
#endif // DOCTEST_CONFIG_SUPER_FAST_ASSERTS
2396

2397
#define DOCTEST_WARN(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN, __VA_ARGS__)
2398
#define DOCTEST_CHECK(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK, __VA_ARGS__)
2399
#define DOCTEST_REQUIRE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE, __VA_ARGS__)
2400
#define DOCTEST_WARN_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_WARN_FALSE, __VA_ARGS__)
2401
#define DOCTEST_CHECK_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_CHECK_FALSE, __VA_ARGS__)
2402
#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_ASSERT_IMPLEMENT_1(DT_REQUIRE_FALSE, __VA_ARGS__)
2403

2404
// clang-format off
2405
#define DOCTEST_WARN_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN, cond); } DOCTEST_FUNC_SCOPE_END
2406
#define DOCTEST_CHECK_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK, cond); } DOCTEST_FUNC_SCOPE_END
2407
#define DOCTEST_REQUIRE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE, cond); } DOCTEST_FUNC_SCOPE_END
2408
#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_WARN_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
2409
#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_CHECK_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
2410
#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_ASSERT_IMPLEMENT_2(DT_REQUIRE_FALSE, cond); } DOCTEST_FUNC_SCOPE_END
2411
// clang-format on
2412

2413
#define DOCTEST_WARN_EQ(...) DOCTEST_BINARY_ASSERT(DT_WARN_EQ, eq, __VA_ARGS__)
2414
#define DOCTEST_CHECK_EQ(...) DOCTEST_BINARY_ASSERT(DT_CHECK_EQ, eq, __VA_ARGS__)
2415
#define DOCTEST_REQUIRE_EQ(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_EQ, eq, __VA_ARGS__)
2416
#define DOCTEST_WARN_NE(...) DOCTEST_BINARY_ASSERT(DT_WARN_NE, ne, __VA_ARGS__)
2417
#define DOCTEST_CHECK_NE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_NE, ne, __VA_ARGS__)
2418
#define DOCTEST_REQUIRE_NE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_NE, ne, __VA_ARGS__)
2419
#define DOCTEST_WARN_GT(...) DOCTEST_BINARY_ASSERT(DT_WARN_GT, gt, __VA_ARGS__)
2420
#define DOCTEST_CHECK_GT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GT, gt, __VA_ARGS__)
2421
#define DOCTEST_REQUIRE_GT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GT, gt, __VA_ARGS__)
2422
#define DOCTEST_WARN_LT(...) DOCTEST_BINARY_ASSERT(DT_WARN_LT, lt, __VA_ARGS__)
2423
#define DOCTEST_CHECK_LT(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LT, lt, __VA_ARGS__)
2424
#define DOCTEST_REQUIRE_LT(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LT, lt, __VA_ARGS__)
2425
#define DOCTEST_WARN_GE(...) DOCTEST_BINARY_ASSERT(DT_WARN_GE, ge, __VA_ARGS__)
2426
#define DOCTEST_CHECK_GE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_GE, ge, __VA_ARGS__)
2427
#define DOCTEST_REQUIRE_GE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_GE, ge, __VA_ARGS__)
2428
#define DOCTEST_WARN_LE(...) DOCTEST_BINARY_ASSERT(DT_WARN_LE, le, __VA_ARGS__)
2429
#define DOCTEST_CHECK_LE(...) DOCTEST_BINARY_ASSERT(DT_CHECK_LE, le, __VA_ARGS__)
2430
#define DOCTEST_REQUIRE_LE(...) DOCTEST_BINARY_ASSERT(DT_REQUIRE_LE, le, __VA_ARGS__)
2431

2432
#define DOCTEST_WARN_UNARY(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY, __VA_ARGS__)
2433
#define DOCTEST_CHECK_UNARY(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY, __VA_ARGS__)
2434
#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY, __VA_ARGS__)
2435
#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_WARN_UNARY_FALSE, __VA_ARGS__)
2436
#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_CHECK_UNARY_FALSE, __VA_ARGS__)
2437
#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_UNARY_ASSERT(DT_REQUIRE_UNARY_FALSE, __VA_ARGS__)
2438

2439
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
2440

2441
#define DOCTEST_ASSERT_THROWS_AS(expr, assert_type, message, ...)                                  \
2442
    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
2443
        if(!doctest::getContextOptions()->no_throw) {                                              \
2444
            doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,  \
2445
                                                       __LINE__, #expr, #__VA_ARGS__, message);    \
2446
            try {                                                                                  \
2447
                DOCTEST_CAST_TO_VOID(expr)                                                         \
2448
            } catch(const typename doctest::detail::types::remove_const< /* NOLINT(modernize-type-traits) */ \
2449
                    typename doctest::detail::types::remove_reference<__VA_ARGS__>::type>::type&) { /* NOLINT(modernize-type-traits) */ \
2450
                DOCTEST_RB.translateException();                                                   \
2451
                DOCTEST_RB.m_threw_as = true;                                                      \
2452
            } catch(...) { DOCTEST_RB.translateException(); }                                      \
2453
            DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                           \
2454
        } else { /* NOLINT(*-else-after-return) */                                                 \
2455
            DOCTEST_FUNC_SCOPE_RET(false);                                                         \
2456
        }                                                                                          \
2457
    } DOCTEST_FUNC_SCOPE_END
2458

2459
#define DOCTEST_ASSERT_THROWS_WITH(expr, expr_str, assert_type, ...)                               \
2460
    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
2461
        if(!doctest::getContextOptions()->no_throw) {                                              \
2462
            doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,  \
2463
                                                       __LINE__, expr_str, "", __VA_ARGS__);       \
2464
            try {                                                                                  \
2465
                DOCTEST_CAST_TO_VOID(expr)                                                         \
2466
            } catch(...) { DOCTEST_RB.translateException(); }                                      \
2467
            DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                           \
2468
        } else { /* NOLINT(*-else-after-return) */                                                 \
2469
           DOCTEST_FUNC_SCOPE_RET(false);                                                          \
2470
        }                                                                                          \
2471
    } DOCTEST_FUNC_SCOPE_END
2472

2473
#define DOCTEST_ASSERT_NOTHROW(assert_type, ...)                                                   \
2474
    DOCTEST_FUNC_SCOPE_BEGIN {                                                                     \
2475
        doctest::detail::ResultBuilder DOCTEST_RB(doctest::assertType::assert_type, __FILE__,      \
2476
                                                   __LINE__, #__VA_ARGS__);                        \
2477
        try {                                                                                      \
2478
            DOCTEST_CAST_TO_VOID(__VA_ARGS__)                                                      \
2479
        } catch(...) { DOCTEST_RB.translateException(); }                                          \
2480
        DOCTEST_ASSERT_LOG_REACT_RETURN(DOCTEST_RB);                                               \
2481
    } DOCTEST_FUNC_SCOPE_END
2482

2483
// clang-format off
2484
#define DOCTEST_WARN_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_WARN_THROWS, "")
2485
#define DOCTEST_CHECK_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_CHECK_THROWS, "")
2486
#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_ASSERT_THROWS_WITH((__VA_ARGS__), #__VA_ARGS__, DT_REQUIRE_THROWS, "")
2487

2488
#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_AS, "", __VA_ARGS__)
2489
#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_AS, "", __VA_ARGS__)
2490
#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_AS, "", __VA_ARGS__)
2491

2492
#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_WARN_THROWS_WITH, __VA_ARGS__)
2493
#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_CHECK_THROWS_WITH, __VA_ARGS__)
2494
#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_ASSERT_THROWS_WITH(expr, #expr, DT_REQUIRE_THROWS_WITH, __VA_ARGS__)
2495

2496
#define DOCTEST_WARN_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_WARN_THROWS_WITH_AS, message, __VA_ARGS__)
2497
#define DOCTEST_CHECK_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_CHECK_THROWS_WITH_AS, message, __VA_ARGS__)
2498
#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, message, ...) DOCTEST_ASSERT_THROWS_AS(expr, DT_REQUIRE_THROWS_WITH_AS, message, __VA_ARGS__)
2499

2500
#define DOCTEST_WARN_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_WARN_NOTHROW, __VA_ARGS__)
2501
#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_CHECK_NOTHROW, __VA_ARGS__)
2502
#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_ASSERT_NOTHROW(DT_REQUIRE_NOTHROW, __VA_ARGS__)
2503

2504
#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
2505
#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
2506
#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS(expr); } DOCTEST_FUNC_SCOPE_END
2507
#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
2508
#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
2509
#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_AS(expr, ex); } DOCTEST_FUNC_SCOPE_END
2510
#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
2511
#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
2512
#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH(expr, with); } DOCTEST_FUNC_SCOPE_END
2513
#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
2514
#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
2515
#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex); } DOCTEST_FUNC_SCOPE_END
2516
#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_WARN_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
2517
#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_CHECK_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
2518
#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_SCOPE_BEGIN { DOCTEST_INFO(__VA_ARGS__); DOCTEST_REQUIRE_NOTHROW(expr); } DOCTEST_FUNC_SCOPE_END
2519
// clang-format on
2520

2521
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
2522

2523
// =================================================================================================
2524
// == WHAT FOLLOWS IS VERSIONS OF THE MACROS THAT DO NOT DO ANY REGISTERING!                      ==
2525
// == THIS CAN BE ENABLED BY DEFINING DOCTEST_CONFIG_DISABLE GLOBALLY!                            ==
2526
// =================================================================================================
2527
#else // DOCTEST_CONFIG_DISABLE
2528

2529
#define DOCTEST_IMPLEMENT_FIXTURE(der, base, func, name)                                           \
2530
    namespace /* NOLINT */ {                                                                       \
2531
        template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                           \
2532
        struct der : public base                                                                   \
2533
        { void f(); };                                                                             \
2534
    }                                                                                              \
2535
    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
2536
    inline void der<DOCTEST_UNUSED_TEMPLATE_TYPE>::f()
2537

2538
#define DOCTEST_CREATE_AND_REGISTER_FUNCTION(f, name)                                              \
2539
    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
2540
    static inline void f()
2541

2542
// for registering tests
2543
#define DOCTEST_TEST_CASE(name)                                                                    \
2544
    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
2545

2546
// for registering tests in classes
2547
#define DOCTEST_TEST_CASE_CLASS(name)                                                              \
2548
    DOCTEST_CREATE_AND_REGISTER_FUNCTION(DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
2549

2550
// for registering tests with a fixture
2551
#define DOCTEST_TEST_CASE_FIXTURE(x, name)                                                         \
2552
    DOCTEST_IMPLEMENT_FIXTURE(DOCTEST_ANONYMOUS(DOCTEST_ANON_CLASS_), x,                           \
2553
                              DOCTEST_ANONYMOUS(DOCTEST_ANON_FUNC_), name)
2554

2555
// for converting types to strings without the <typeinfo> header and demangling
2556
#define DOCTEST_TYPE_TO_STRING_AS(str, ...) static_assert(true, "")
2557
#define DOCTEST_TYPE_TO_STRING(...) static_assert(true, "")
2558

2559
// for typed tests
2560
#define DOCTEST_TEST_CASE_TEMPLATE(name, type, ...)                                                \
2561
    template <typename type>                                                                       \
2562
    inline void DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_)()
2563

2564
#define DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, type, id)                                          \
2565
    template <typename type>                                                                       \
2566
    inline void DOCTEST_ANONYMOUS(DOCTEST_ANON_TMP_)()
2567

2568
#define DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, ...) static_assert(true, "")
2569
#define DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, ...) static_assert(true, "")
2570

2571
// for subcases
2572
#define DOCTEST_SUBCASE(name)
2573

2574
// for a testsuite block
2575
#define DOCTEST_TEST_SUITE(name) namespace // NOLINT
2576

2577
// for starting a testsuite block
2578
#define DOCTEST_TEST_SUITE_BEGIN(name) static_assert(true, "")
2579

2580
// for ending a testsuite block
2581
#define DOCTEST_TEST_SUITE_END using DOCTEST_ANONYMOUS(DOCTEST_ANON_FOR_SEMICOLON_) = int
2582

2583
#define DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)                                           \
2584
    template <typename DOCTEST_UNUSED_TEMPLATE_TYPE>                                               \
2585
    static inline doctest::String DOCTEST_ANONYMOUS(DOCTEST_ANON_TRANSLATOR_)(signature)
2586

2587
#define DOCTEST_REGISTER_REPORTER(name, priority, reporter)
2588
#define DOCTEST_REGISTER_LISTENER(name, priority, reporter)
2589

2590
#define DOCTEST_INFO(...) (static_cast<void>(0))
2591
#define DOCTEST_CAPTURE(x) (static_cast<void>(0))
2592
#define DOCTEST_ADD_MESSAGE_AT(file, line, ...) (static_cast<void>(0))
2593
#define DOCTEST_ADD_FAIL_CHECK_AT(file, line, ...) (static_cast<void>(0))
2594
#define DOCTEST_ADD_FAIL_AT(file, line, ...) (static_cast<void>(0))
2595
#define DOCTEST_MESSAGE(...) (static_cast<void>(0))
2596
#define DOCTEST_FAIL_CHECK(...) (static_cast<void>(0))
2597
#define DOCTEST_FAIL(...) (static_cast<void>(0))
2598

2599
#if defined(DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED)                                    \
2600
 && defined(DOCTEST_CONFIG_ASSERTS_RETURN_VALUES)
2601

2602
#define DOCTEST_WARN(...) [&] { return __VA_ARGS__; }()
2603
#define DOCTEST_CHECK(...) [&] { return __VA_ARGS__; }()
2604
#define DOCTEST_REQUIRE(...) [&] { return __VA_ARGS__; }()
2605
#define DOCTEST_WARN_FALSE(...) [&] { return !(__VA_ARGS__); }()
2606
#define DOCTEST_CHECK_FALSE(...) [&] { return !(__VA_ARGS__); }()
2607
#define DOCTEST_REQUIRE_FALSE(...) [&] { return !(__VA_ARGS__); }()
2608

2609
#define DOCTEST_WARN_MESSAGE(cond, ...) [&] { return cond; }()
2610
#define DOCTEST_CHECK_MESSAGE(cond, ...) [&] { return cond; }()
2611
#define DOCTEST_REQUIRE_MESSAGE(cond, ...) [&] { return cond; }()
2612
#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
2613
#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
2614
#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) [&] { return !(cond); }()
2615

2616
namespace doctest {
2617
namespace detail {
2618
#define DOCTEST_RELATIONAL_OP(name, op)                                                            \
2619
    template <typename L, typename R>                                                              \
2620
    bool name(const DOCTEST_REF_WRAP(L) lhs, const DOCTEST_REF_WRAP(R) rhs) { return lhs op rhs; }
2621

2622
    DOCTEST_RELATIONAL_OP(eq, ==)
2623
    DOCTEST_RELATIONAL_OP(ne, !=)
2624
    DOCTEST_RELATIONAL_OP(lt, <)
2625
    DOCTEST_RELATIONAL_OP(gt, >)
2626
    DOCTEST_RELATIONAL_OP(le, <=)
2627
    DOCTEST_RELATIONAL_OP(ge, >=)
2628
} // namespace detail
2629
} // namespace doctest
2630

2631
#define DOCTEST_WARN_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
2632
#define DOCTEST_CHECK_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
2633
#define DOCTEST_REQUIRE_EQ(...) [&] { return doctest::detail::eq(__VA_ARGS__); }()
2634
#define DOCTEST_WARN_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
2635
#define DOCTEST_CHECK_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
2636
#define DOCTEST_REQUIRE_NE(...) [&] { return doctest::detail::ne(__VA_ARGS__); }()
2637
#define DOCTEST_WARN_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
2638
#define DOCTEST_CHECK_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
2639
#define DOCTEST_REQUIRE_LT(...) [&] { return doctest::detail::lt(__VA_ARGS__); }()
2640
#define DOCTEST_WARN_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
2641
#define DOCTEST_CHECK_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
2642
#define DOCTEST_REQUIRE_GT(...) [&] { return doctest::detail::gt(__VA_ARGS__); }()
2643
#define DOCTEST_WARN_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
2644
#define DOCTEST_CHECK_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
2645
#define DOCTEST_REQUIRE_LE(...) [&] { return doctest::detail::le(__VA_ARGS__); }()
2646
#define DOCTEST_WARN_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
2647
#define DOCTEST_CHECK_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
2648
#define DOCTEST_REQUIRE_GE(...) [&] { return doctest::detail::ge(__VA_ARGS__); }()
2649
#define DOCTEST_WARN_UNARY(...) [&] { return __VA_ARGS__; }()
2650
#define DOCTEST_CHECK_UNARY(...) [&] { return __VA_ARGS__; }()
2651
#define DOCTEST_REQUIRE_UNARY(...) [&] { return __VA_ARGS__; }()
2652
#define DOCTEST_WARN_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
2653
#define DOCTEST_CHECK_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
2654
#define DOCTEST_REQUIRE_UNARY_FALSE(...) [&] { return !(__VA_ARGS__); }()
2655

2656
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
2657

2658
#define DOCTEST_WARN_THROWS_WITH(expr, with, ...) [] { static_assert(false, "Exception translation is not available when doctest is disabled."); return false; }()
2659
#define DOCTEST_CHECK_THROWS_WITH(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
2660
#define DOCTEST_REQUIRE_THROWS_WITH(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
2661
#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
2662
#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
2663
#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
2664

2665
#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
2666
#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
2667
#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH(,,)
2668
#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
2669
#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
2670
#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH(,,)
2671

2672
#define DOCTEST_WARN_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
2673
#define DOCTEST_CHECK_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
2674
#define DOCTEST_REQUIRE_THROWS(...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
2675
#define DOCTEST_WARN_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
2676
#define DOCTEST_CHECK_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
2677
#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
2678
#define DOCTEST_WARN_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
2679
#define DOCTEST_CHECK_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
2680
#define DOCTEST_REQUIRE_NOTHROW(...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
2681

2682
#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
2683
#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
2684
#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return false; } catch (...) { return true; } }()
2685
#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
2686
#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
2687
#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) [&] { try { expr; } catch (__VA_ARGS__) { return true; } catch (...) { } return false; }()
2688
#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
2689
#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
2690
#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) [&] { try { __VA_ARGS__; return true; } catch (...) { return false; } }()
2691

2692
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
2693

2694
#else // DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED
2695

2696
#define DOCTEST_WARN(...) DOCTEST_FUNC_EMPTY
2697
#define DOCTEST_CHECK(...) DOCTEST_FUNC_EMPTY
2698
#define DOCTEST_REQUIRE(...) DOCTEST_FUNC_EMPTY
2699
#define DOCTEST_WARN_FALSE(...) DOCTEST_FUNC_EMPTY
2700
#define DOCTEST_CHECK_FALSE(...) DOCTEST_FUNC_EMPTY
2701
#define DOCTEST_REQUIRE_FALSE(...) DOCTEST_FUNC_EMPTY
2702

2703
#define DOCTEST_WARN_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
2704
#define DOCTEST_CHECK_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
2705
#define DOCTEST_REQUIRE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
2706
#define DOCTEST_WARN_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
2707
#define DOCTEST_CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
2708
#define DOCTEST_REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_FUNC_EMPTY
2709

2710
#define DOCTEST_WARN_EQ(...) DOCTEST_FUNC_EMPTY
2711
#define DOCTEST_CHECK_EQ(...) DOCTEST_FUNC_EMPTY
2712
#define DOCTEST_REQUIRE_EQ(...) DOCTEST_FUNC_EMPTY
2713
#define DOCTEST_WARN_NE(...) DOCTEST_FUNC_EMPTY
2714
#define DOCTEST_CHECK_NE(...) DOCTEST_FUNC_EMPTY
2715
#define DOCTEST_REQUIRE_NE(...) DOCTEST_FUNC_EMPTY
2716
#define DOCTEST_WARN_GT(...) DOCTEST_FUNC_EMPTY
2717
#define DOCTEST_CHECK_GT(...) DOCTEST_FUNC_EMPTY
2718
#define DOCTEST_REQUIRE_GT(...) DOCTEST_FUNC_EMPTY
2719
#define DOCTEST_WARN_LT(...) DOCTEST_FUNC_EMPTY
2720
#define DOCTEST_CHECK_LT(...) DOCTEST_FUNC_EMPTY
2721
#define DOCTEST_REQUIRE_LT(...) DOCTEST_FUNC_EMPTY
2722
#define DOCTEST_WARN_GE(...) DOCTEST_FUNC_EMPTY
2723
#define DOCTEST_CHECK_GE(...) DOCTEST_FUNC_EMPTY
2724
#define DOCTEST_REQUIRE_GE(...) DOCTEST_FUNC_EMPTY
2725
#define DOCTEST_WARN_LE(...) DOCTEST_FUNC_EMPTY
2726
#define DOCTEST_CHECK_LE(...) DOCTEST_FUNC_EMPTY
2727
#define DOCTEST_REQUIRE_LE(...) DOCTEST_FUNC_EMPTY
2728

2729
#define DOCTEST_WARN_UNARY(...) DOCTEST_FUNC_EMPTY
2730
#define DOCTEST_CHECK_UNARY(...) DOCTEST_FUNC_EMPTY
2731
#define DOCTEST_REQUIRE_UNARY(...) DOCTEST_FUNC_EMPTY
2732
#define DOCTEST_WARN_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
2733
#define DOCTEST_CHECK_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
2734
#define DOCTEST_REQUIRE_UNARY_FALSE(...) DOCTEST_FUNC_EMPTY
2735

2736
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
2737

2738
#define DOCTEST_WARN_THROWS(...) DOCTEST_FUNC_EMPTY
2739
#define DOCTEST_CHECK_THROWS(...) DOCTEST_FUNC_EMPTY
2740
#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_FUNC_EMPTY
2741
#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
2742
#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
2743
#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_FUNC_EMPTY
2744
#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
2745
#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
2746
#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_FUNC_EMPTY
2747
#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
2748
#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
2749
#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_FUNC_EMPTY
2750
#define DOCTEST_WARN_NOTHROW(...) DOCTEST_FUNC_EMPTY
2751
#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_FUNC_EMPTY
2752
#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_FUNC_EMPTY
2753

2754
#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
2755
#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
2756
#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
2757
#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
2758
#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
2759
#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_FUNC_EMPTY
2760
#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
2761
#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
2762
#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_FUNC_EMPTY
2763
#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
2764
#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
2765
#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_FUNC_EMPTY
2766
#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
2767
#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
2768
#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_FUNC_EMPTY
2769

2770
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
2771

2772
#endif // DOCTEST_CONFIG_EVALUATE_ASSERTS_EVEN_WHEN_DISABLED
2773

2774
#endif // DOCTEST_CONFIG_DISABLE
2775

2776
#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS
2777

2778
#ifdef DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
2779
#define DOCTEST_EXCEPTION_EMPTY_FUNC DOCTEST_FUNC_EMPTY
2780
#else // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
2781
#define DOCTEST_EXCEPTION_EMPTY_FUNC [] { static_assert(false, "Exceptions are disabled! " \
2782
    "Use DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS if you want to compile with exceptions disabled."); return false; }()
2783

2784
#undef DOCTEST_REQUIRE
2785
#undef DOCTEST_REQUIRE_FALSE
2786
#undef DOCTEST_REQUIRE_MESSAGE
2787
#undef DOCTEST_REQUIRE_FALSE_MESSAGE
2788
#undef DOCTEST_REQUIRE_EQ
2789
#undef DOCTEST_REQUIRE_NE
2790
#undef DOCTEST_REQUIRE_GT
2791
#undef DOCTEST_REQUIRE_LT
2792
#undef DOCTEST_REQUIRE_GE
2793
#undef DOCTEST_REQUIRE_LE
2794
#undef DOCTEST_REQUIRE_UNARY
2795
#undef DOCTEST_REQUIRE_UNARY_FALSE
2796

2797
#define DOCTEST_REQUIRE DOCTEST_EXCEPTION_EMPTY_FUNC
2798
#define DOCTEST_REQUIRE_FALSE DOCTEST_EXCEPTION_EMPTY_FUNC
2799
#define DOCTEST_REQUIRE_MESSAGE DOCTEST_EXCEPTION_EMPTY_FUNC
2800
#define DOCTEST_REQUIRE_FALSE_MESSAGE DOCTEST_EXCEPTION_EMPTY_FUNC
2801
#define DOCTEST_REQUIRE_EQ DOCTEST_EXCEPTION_EMPTY_FUNC
2802
#define DOCTEST_REQUIRE_NE DOCTEST_EXCEPTION_EMPTY_FUNC
2803
#define DOCTEST_REQUIRE_GT DOCTEST_EXCEPTION_EMPTY_FUNC
2804
#define DOCTEST_REQUIRE_LT DOCTEST_EXCEPTION_EMPTY_FUNC
2805
#define DOCTEST_REQUIRE_GE DOCTEST_EXCEPTION_EMPTY_FUNC
2806
#define DOCTEST_REQUIRE_LE DOCTEST_EXCEPTION_EMPTY_FUNC
2807
#define DOCTEST_REQUIRE_UNARY DOCTEST_EXCEPTION_EMPTY_FUNC
2808
#define DOCTEST_REQUIRE_UNARY_FALSE DOCTEST_EXCEPTION_EMPTY_FUNC
2809

2810
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS_BUT_WITH_ALL_ASSERTS
2811

2812
#define DOCTEST_WARN_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
2813
#define DOCTEST_CHECK_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
2814
#define DOCTEST_REQUIRE_THROWS(...) DOCTEST_EXCEPTION_EMPTY_FUNC
2815
#define DOCTEST_WARN_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2816
#define DOCTEST_CHECK_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2817
#define DOCTEST_REQUIRE_THROWS_AS(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2818
#define DOCTEST_WARN_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2819
#define DOCTEST_CHECK_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2820
#define DOCTEST_REQUIRE_THROWS_WITH(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2821
#define DOCTEST_WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2822
#define DOCTEST_CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2823
#define DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2824
#define DOCTEST_WARN_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
2825
#define DOCTEST_CHECK_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
2826
#define DOCTEST_REQUIRE_NOTHROW(...) DOCTEST_EXCEPTION_EMPTY_FUNC
2827

2828
#define DOCTEST_WARN_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2829
#define DOCTEST_CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2830
#define DOCTEST_REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2831
#define DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2832
#define DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2833
#define DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2834
#define DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2835
#define DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2836
#define DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2837
#define DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2838
#define DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2839
#define DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2840
#define DOCTEST_WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2841
#define DOCTEST_CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2842
#define DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_EXCEPTION_EMPTY_FUNC
2843

2844
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
2845

2846
// clang-format off
2847
// KEPT FOR BACKWARDS COMPATIBILITY - FORWARDING TO THE RIGHT MACROS
2848
#define DOCTEST_FAST_WARN_EQ             DOCTEST_WARN_EQ
2849
#define DOCTEST_FAST_CHECK_EQ            DOCTEST_CHECK_EQ
2850
#define DOCTEST_FAST_REQUIRE_EQ          DOCTEST_REQUIRE_EQ
2851
#define DOCTEST_FAST_WARN_NE             DOCTEST_WARN_NE
2852
#define DOCTEST_FAST_CHECK_NE            DOCTEST_CHECK_NE
2853
#define DOCTEST_FAST_REQUIRE_NE          DOCTEST_REQUIRE_NE
2854
#define DOCTEST_FAST_WARN_GT             DOCTEST_WARN_GT
2855
#define DOCTEST_FAST_CHECK_GT            DOCTEST_CHECK_GT
2856
#define DOCTEST_FAST_REQUIRE_GT          DOCTEST_REQUIRE_GT
2857
#define DOCTEST_FAST_WARN_LT             DOCTEST_WARN_LT
2858
#define DOCTEST_FAST_CHECK_LT            DOCTEST_CHECK_LT
2859
#define DOCTEST_FAST_REQUIRE_LT          DOCTEST_REQUIRE_LT
2860
#define DOCTEST_FAST_WARN_GE             DOCTEST_WARN_GE
2861
#define DOCTEST_FAST_CHECK_GE            DOCTEST_CHECK_GE
2862
#define DOCTEST_FAST_REQUIRE_GE          DOCTEST_REQUIRE_GE
2863
#define DOCTEST_FAST_WARN_LE             DOCTEST_WARN_LE
2864
#define DOCTEST_FAST_CHECK_LE            DOCTEST_CHECK_LE
2865
#define DOCTEST_FAST_REQUIRE_LE          DOCTEST_REQUIRE_LE
2866

2867
#define DOCTEST_FAST_WARN_UNARY          DOCTEST_WARN_UNARY
2868
#define DOCTEST_FAST_CHECK_UNARY         DOCTEST_CHECK_UNARY
2869
#define DOCTEST_FAST_REQUIRE_UNARY       DOCTEST_REQUIRE_UNARY
2870
#define DOCTEST_FAST_WARN_UNARY_FALSE    DOCTEST_WARN_UNARY_FALSE
2871
#define DOCTEST_FAST_CHECK_UNARY_FALSE   DOCTEST_CHECK_UNARY_FALSE
2872
#define DOCTEST_FAST_REQUIRE_UNARY_FALSE DOCTEST_REQUIRE_UNARY_FALSE
2873

2874
#define DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id,__VA_ARGS__)
2875
// clang-format on
2876

2877
// BDD style macros
2878
// clang-format off
2879
#define DOCTEST_SCENARIO(name) DOCTEST_TEST_CASE("  Scenario: " name)
2880
#define DOCTEST_SCENARIO_CLASS(name) DOCTEST_TEST_CASE_CLASS("  Scenario: " name)
2881
#define DOCTEST_SCENARIO_TEMPLATE(name, T, ...)  DOCTEST_TEST_CASE_TEMPLATE("  Scenario: " name, T, __VA_ARGS__)
2882
#define DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE("  Scenario: " name, T, id)
2883

2884
#define DOCTEST_GIVEN(name)     DOCTEST_SUBCASE("   Given: " name)
2885
#define DOCTEST_WHEN(name)      DOCTEST_SUBCASE("    When: " name)
2886
#define DOCTEST_AND_WHEN(name)  DOCTEST_SUBCASE("And when: " name)
2887
#define DOCTEST_THEN(name)      DOCTEST_SUBCASE("    Then: " name)
2888
#define DOCTEST_AND_THEN(name)  DOCTEST_SUBCASE("     And: " name)
2889
// clang-format on
2890

2891
// == SHORT VERSIONS OF THE MACROS
2892
#ifndef DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES
2893

2894
#define TEST_CASE(name) DOCTEST_TEST_CASE(name)
2895
#define TEST_CASE_CLASS(name) DOCTEST_TEST_CASE_CLASS(name)
2896
#define TEST_CASE_FIXTURE(x, name) DOCTEST_TEST_CASE_FIXTURE(x, name)
2897
#define TYPE_TO_STRING_AS(str, ...) DOCTEST_TYPE_TO_STRING_AS(str, __VA_ARGS__)
2898
#define TYPE_TO_STRING(...) DOCTEST_TYPE_TO_STRING(__VA_ARGS__)
2899
#define TEST_CASE_TEMPLATE(name, T, ...) DOCTEST_TEST_CASE_TEMPLATE(name, T, __VA_ARGS__)
2900
#define TEST_CASE_TEMPLATE_DEFINE(name, T, id) DOCTEST_TEST_CASE_TEMPLATE_DEFINE(name, T, id)
2901
#define TEST_CASE_TEMPLATE_INVOKE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INVOKE(id, __VA_ARGS__)
2902
#define TEST_CASE_TEMPLATE_APPLY(id, ...) DOCTEST_TEST_CASE_TEMPLATE_APPLY(id, __VA_ARGS__)
2903
#define SUBCASE(name) DOCTEST_SUBCASE(name)
2904
#define TEST_SUITE(decorators) DOCTEST_TEST_SUITE(decorators)
2905
#define TEST_SUITE_BEGIN(name) DOCTEST_TEST_SUITE_BEGIN(name)
2906
#define TEST_SUITE_END DOCTEST_TEST_SUITE_END
2907
#define REGISTER_EXCEPTION_TRANSLATOR(signature) DOCTEST_REGISTER_EXCEPTION_TRANSLATOR(signature)
2908
#define REGISTER_REPORTER(name, priority, reporter) DOCTEST_REGISTER_REPORTER(name, priority, reporter)
2909
#define REGISTER_LISTENER(name, priority, reporter) DOCTEST_REGISTER_LISTENER(name, priority, reporter)
2910
#define INFO(...) DOCTEST_INFO(__VA_ARGS__)
2911
#define CAPTURE(x) DOCTEST_CAPTURE(x)
2912
#define ADD_MESSAGE_AT(file, line, ...) DOCTEST_ADD_MESSAGE_AT(file, line, __VA_ARGS__)
2913
#define ADD_FAIL_CHECK_AT(file, line, ...) DOCTEST_ADD_FAIL_CHECK_AT(file, line, __VA_ARGS__)
2914
#define ADD_FAIL_AT(file, line, ...) DOCTEST_ADD_FAIL_AT(file, line, __VA_ARGS__)
2915
#define MESSAGE(...) DOCTEST_MESSAGE(__VA_ARGS__)
2916
#define FAIL_CHECK(...) DOCTEST_FAIL_CHECK(__VA_ARGS__)
2917
#define FAIL(...) DOCTEST_FAIL(__VA_ARGS__)
2918
#define TO_LVALUE(...) DOCTEST_TO_LVALUE(__VA_ARGS__)
2919

2920
#define WARN(...) DOCTEST_WARN(__VA_ARGS__)
2921
#define WARN_FALSE(...) DOCTEST_WARN_FALSE(__VA_ARGS__)
2922
#define WARN_THROWS(...) DOCTEST_WARN_THROWS(__VA_ARGS__)
2923
#define WARN_THROWS_AS(expr, ...) DOCTEST_WARN_THROWS_AS(expr, __VA_ARGS__)
2924
#define WARN_THROWS_WITH(expr, ...) DOCTEST_WARN_THROWS_WITH(expr, __VA_ARGS__)
2925
#define WARN_THROWS_WITH_AS(expr, with, ...) DOCTEST_WARN_THROWS_WITH_AS(expr, with, __VA_ARGS__)
2926
#define WARN_NOTHROW(...) DOCTEST_WARN_NOTHROW(__VA_ARGS__)
2927
#define CHECK(...) DOCTEST_CHECK(__VA_ARGS__)
2928
#define CHECK_FALSE(...) DOCTEST_CHECK_FALSE(__VA_ARGS__)
2929
#define CHECK_THROWS(...) DOCTEST_CHECK_THROWS(__VA_ARGS__)
2930
#define CHECK_THROWS_AS(expr, ...) DOCTEST_CHECK_THROWS_AS(expr, __VA_ARGS__)
2931
#define CHECK_THROWS_WITH(expr, ...) DOCTEST_CHECK_THROWS_WITH(expr, __VA_ARGS__)
2932
#define CHECK_THROWS_WITH_AS(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_AS(expr, with, __VA_ARGS__)
2933
#define CHECK_NOTHROW(...) DOCTEST_CHECK_NOTHROW(__VA_ARGS__)
2934
#define REQUIRE(...) DOCTEST_REQUIRE(__VA_ARGS__)
2935
#define REQUIRE_FALSE(...) DOCTEST_REQUIRE_FALSE(__VA_ARGS__)
2936
#define REQUIRE_THROWS(...) DOCTEST_REQUIRE_THROWS(__VA_ARGS__)
2937
#define REQUIRE_THROWS_AS(expr, ...) DOCTEST_REQUIRE_THROWS_AS(expr, __VA_ARGS__)
2938
#define REQUIRE_THROWS_WITH(expr, ...) DOCTEST_REQUIRE_THROWS_WITH(expr, __VA_ARGS__)
2939
#define REQUIRE_THROWS_WITH_AS(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_AS(expr, with, __VA_ARGS__)
2940
#define REQUIRE_NOTHROW(...) DOCTEST_REQUIRE_NOTHROW(__VA_ARGS__)
2941

2942
#define WARN_MESSAGE(cond, ...) DOCTEST_WARN_MESSAGE(cond, __VA_ARGS__)
2943
#define WARN_FALSE_MESSAGE(cond, ...) DOCTEST_WARN_FALSE_MESSAGE(cond, __VA_ARGS__)
2944
#define WARN_THROWS_MESSAGE(expr, ...) DOCTEST_WARN_THROWS_MESSAGE(expr, __VA_ARGS__)
2945
#define WARN_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_WARN_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
2946
#define WARN_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_WARN_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
2947
#define WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_WARN_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
2948
#define WARN_NOTHROW_MESSAGE(expr, ...) DOCTEST_WARN_NOTHROW_MESSAGE(expr, __VA_ARGS__)
2949
#define CHECK_MESSAGE(cond, ...) DOCTEST_CHECK_MESSAGE(cond, __VA_ARGS__)
2950
#define CHECK_FALSE_MESSAGE(cond, ...) DOCTEST_CHECK_FALSE_MESSAGE(cond, __VA_ARGS__)
2951
#define CHECK_THROWS_MESSAGE(expr, ...) DOCTEST_CHECK_THROWS_MESSAGE(expr, __VA_ARGS__)
2952
#define CHECK_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_CHECK_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
2953
#define CHECK_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_CHECK_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
2954
#define CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_CHECK_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
2955
#define CHECK_NOTHROW_MESSAGE(expr, ...) DOCTEST_CHECK_NOTHROW_MESSAGE(expr, __VA_ARGS__)
2956
#define REQUIRE_MESSAGE(cond, ...) DOCTEST_REQUIRE_MESSAGE(cond, __VA_ARGS__)
2957
#define REQUIRE_FALSE_MESSAGE(cond, ...) DOCTEST_REQUIRE_FALSE_MESSAGE(cond, __VA_ARGS__)
2958
#define REQUIRE_THROWS_MESSAGE(expr, ...) DOCTEST_REQUIRE_THROWS_MESSAGE(expr, __VA_ARGS__)
2959
#define REQUIRE_THROWS_AS_MESSAGE(expr, ex, ...) DOCTEST_REQUIRE_THROWS_AS_MESSAGE(expr, ex, __VA_ARGS__)
2960
#define REQUIRE_THROWS_WITH_MESSAGE(expr, with, ...) DOCTEST_REQUIRE_THROWS_WITH_MESSAGE(expr, with, __VA_ARGS__)
2961
#define REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, ...) DOCTEST_REQUIRE_THROWS_WITH_AS_MESSAGE(expr, with, ex, __VA_ARGS__)
2962
#define REQUIRE_NOTHROW_MESSAGE(expr, ...) DOCTEST_REQUIRE_NOTHROW_MESSAGE(expr, __VA_ARGS__)
2963

2964
#define SCENARIO(name) DOCTEST_SCENARIO(name)
2965
#define SCENARIO_CLASS(name) DOCTEST_SCENARIO_CLASS(name)
2966
#define SCENARIO_TEMPLATE(name, T, ...) DOCTEST_SCENARIO_TEMPLATE(name, T, __VA_ARGS__)
2967
#define SCENARIO_TEMPLATE_DEFINE(name, T, id) DOCTEST_SCENARIO_TEMPLATE_DEFINE(name, T, id)
2968
#define GIVEN(name) DOCTEST_GIVEN(name)
2969
#define WHEN(name) DOCTEST_WHEN(name)
2970
#define AND_WHEN(name) DOCTEST_AND_WHEN(name)
2971
#define THEN(name) DOCTEST_THEN(name)
2972
#define AND_THEN(name) DOCTEST_AND_THEN(name)
2973

2974
#define WARN_EQ(...) DOCTEST_WARN_EQ(__VA_ARGS__)
2975
#define CHECK_EQ(...) DOCTEST_CHECK_EQ(__VA_ARGS__)
2976
#define REQUIRE_EQ(...) DOCTEST_REQUIRE_EQ(__VA_ARGS__)
2977
#define WARN_NE(...) DOCTEST_WARN_NE(__VA_ARGS__)
2978
#define CHECK_NE(...) DOCTEST_CHECK_NE(__VA_ARGS__)
2979
#define REQUIRE_NE(...) DOCTEST_REQUIRE_NE(__VA_ARGS__)
2980
#define WARN_GT(...) DOCTEST_WARN_GT(__VA_ARGS__)
2981
#define CHECK_GT(...) DOCTEST_CHECK_GT(__VA_ARGS__)
2982
#define REQUIRE_GT(...) DOCTEST_REQUIRE_GT(__VA_ARGS__)
2983
#define WARN_LT(...) DOCTEST_WARN_LT(__VA_ARGS__)
2984
#define CHECK_LT(...) DOCTEST_CHECK_LT(__VA_ARGS__)
2985
#define REQUIRE_LT(...) DOCTEST_REQUIRE_LT(__VA_ARGS__)
2986
#define WARN_GE(...) DOCTEST_WARN_GE(__VA_ARGS__)
2987
#define CHECK_GE(...) DOCTEST_CHECK_GE(__VA_ARGS__)
2988
#define REQUIRE_GE(...) DOCTEST_REQUIRE_GE(__VA_ARGS__)
2989
#define WARN_LE(...) DOCTEST_WARN_LE(__VA_ARGS__)
2990
#define CHECK_LE(...) DOCTEST_CHECK_LE(__VA_ARGS__)
2991
#define REQUIRE_LE(...) DOCTEST_REQUIRE_LE(__VA_ARGS__)
2992
#define WARN_UNARY(...) DOCTEST_WARN_UNARY(__VA_ARGS__)
2993
#define CHECK_UNARY(...) DOCTEST_CHECK_UNARY(__VA_ARGS__)
2994
#define REQUIRE_UNARY(...) DOCTEST_REQUIRE_UNARY(__VA_ARGS__)
2995
#define WARN_UNARY_FALSE(...) DOCTEST_WARN_UNARY_FALSE(__VA_ARGS__)
2996
#define CHECK_UNARY_FALSE(...) DOCTEST_CHECK_UNARY_FALSE(__VA_ARGS__)
2997
#define REQUIRE_UNARY_FALSE(...) DOCTEST_REQUIRE_UNARY_FALSE(__VA_ARGS__)
2998

2999
// KEPT FOR BACKWARDS COMPATIBILITY
3000
#define FAST_WARN_EQ(...) DOCTEST_FAST_WARN_EQ(__VA_ARGS__)
3001
#define FAST_CHECK_EQ(...) DOCTEST_FAST_CHECK_EQ(__VA_ARGS__)
3002
#define FAST_REQUIRE_EQ(...) DOCTEST_FAST_REQUIRE_EQ(__VA_ARGS__)
3003
#define FAST_WARN_NE(...) DOCTEST_FAST_WARN_NE(__VA_ARGS__)
3004
#define FAST_CHECK_NE(...) DOCTEST_FAST_CHECK_NE(__VA_ARGS__)
3005
#define FAST_REQUIRE_NE(...) DOCTEST_FAST_REQUIRE_NE(__VA_ARGS__)
3006
#define FAST_WARN_GT(...) DOCTEST_FAST_WARN_GT(__VA_ARGS__)
3007
#define FAST_CHECK_GT(...) DOCTEST_FAST_CHECK_GT(__VA_ARGS__)
3008
#define FAST_REQUIRE_GT(...) DOCTEST_FAST_REQUIRE_GT(__VA_ARGS__)
3009
#define FAST_WARN_LT(...) DOCTEST_FAST_WARN_LT(__VA_ARGS__)
3010
#define FAST_CHECK_LT(...) DOCTEST_FAST_CHECK_LT(__VA_ARGS__)
3011
#define FAST_REQUIRE_LT(...) DOCTEST_FAST_REQUIRE_LT(__VA_ARGS__)
3012
#define FAST_WARN_GE(...) DOCTEST_FAST_WARN_GE(__VA_ARGS__)
3013
#define FAST_CHECK_GE(...) DOCTEST_FAST_CHECK_GE(__VA_ARGS__)
3014
#define FAST_REQUIRE_GE(...) DOCTEST_FAST_REQUIRE_GE(__VA_ARGS__)
3015
#define FAST_WARN_LE(...) DOCTEST_FAST_WARN_LE(__VA_ARGS__)
3016
#define FAST_CHECK_LE(...) DOCTEST_FAST_CHECK_LE(__VA_ARGS__)
3017
#define FAST_REQUIRE_LE(...) DOCTEST_FAST_REQUIRE_LE(__VA_ARGS__)
3018

3019
#define FAST_WARN_UNARY(...) DOCTEST_FAST_WARN_UNARY(__VA_ARGS__)
3020
#define FAST_CHECK_UNARY(...) DOCTEST_FAST_CHECK_UNARY(__VA_ARGS__)
3021
#define FAST_REQUIRE_UNARY(...) DOCTEST_FAST_REQUIRE_UNARY(__VA_ARGS__)
3022
#define FAST_WARN_UNARY_FALSE(...) DOCTEST_FAST_WARN_UNARY_FALSE(__VA_ARGS__)
3023
#define FAST_CHECK_UNARY_FALSE(...) DOCTEST_FAST_CHECK_UNARY_FALSE(__VA_ARGS__)
3024
#define FAST_REQUIRE_UNARY_FALSE(...) DOCTEST_FAST_REQUIRE_UNARY_FALSE(__VA_ARGS__)
3025

3026
#define TEST_CASE_TEMPLATE_INSTANTIATE(id, ...) DOCTEST_TEST_CASE_TEMPLATE_INSTANTIATE(id, __VA_ARGS__)
3027

3028
#endif // DOCTEST_CONFIG_NO_SHORT_MACRO_NAMES
3029

3030
#ifndef DOCTEST_CONFIG_DISABLE
3031

3032
// this is here to clear the 'current test suite' for the current translation unit - at the top
3033
DOCTEST_TEST_SUITE_END();
3034

3035
#endif // DOCTEST_CONFIG_DISABLE
3036

3037
DOCTEST_CLANG_SUPPRESS_WARNING_POP
3038
DOCTEST_MSVC_SUPPRESS_WARNING_POP
3039
DOCTEST_GCC_SUPPRESS_WARNING_POP
3040

3041
DOCTEST_SUPPRESS_COMMON_WARNINGS_POP
3042

3043
#endif // DOCTEST_LIBRARY_INCLUDED
3044

3045
#ifndef DOCTEST_SINGLE_HEADER
3046
#define DOCTEST_SINGLE_HEADER
3047
#endif // DOCTEST_SINGLE_HEADER
3048

3049
#if defined(DOCTEST_CONFIG_IMPLEMENT) || !defined(DOCTEST_SINGLE_HEADER)
3050

3051
#ifndef DOCTEST_SINGLE_HEADER
3052
#include "doctest_fwd.h"
3053
#endif // DOCTEST_SINGLE_HEADER
3054

3055
DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wunused-macros")
3056

3057
#ifndef DOCTEST_LIBRARY_IMPLEMENTATION
3058
#define DOCTEST_LIBRARY_IMPLEMENTATION
3059

3060
DOCTEST_CLANG_SUPPRESS_WARNING_POP
3061

3062
DOCTEST_SUPPRESS_COMMON_WARNINGS_PUSH
3063

3064
DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
3065
DOCTEST_CLANG_SUPPRESS_WARNING("-Wglobal-constructors")
3066
DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
3067
DOCTEST_CLANG_SUPPRESS_WARNING("-Wsign-conversion")
3068
DOCTEST_CLANG_SUPPRESS_WARNING("-Wshorten-64-to-32")
3069
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-variable-declarations")
3070
DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch")
3071
DOCTEST_CLANG_SUPPRESS_WARNING("-Wswitch-enum")
3072
DOCTEST_CLANG_SUPPRESS_WARNING("-Wcovered-switch-default")
3073
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-noreturn")
3074
DOCTEST_CLANG_SUPPRESS_WARNING("-Wdisabled-macro-expansion")
3075
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-braces")
3076
DOCTEST_CLANG_SUPPRESS_WARNING("-Wmissing-field-initializers")
3077
DOCTEST_CLANG_SUPPRESS_WARNING("-Wunused-member-function")
3078
DOCTEST_CLANG_SUPPRESS_WARNING("-Wnonportable-system-include-path")
3079

3080
DOCTEST_GCC_SUPPRESS_WARNING_PUSH
3081
DOCTEST_GCC_SUPPRESS_WARNING("-Wconversion")
3082
DOCTEST_GCC_SUPPRESS_WARNING("-Wsign-conversion")
3083
DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-field-initializers")
3084
DOCTEST_GCC_SUPPRESS_WARNING("-Wmissing-braces")
3085
DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch")
3086
DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-enum")
3087
DOCTEST_GCC_SUPPRESS_WARNING("-Wswitch-default")
3088
DOCTEST_GCC_SUPPRESS_WARNING("-Wunsafe-loop-optimizations")
3089
DOCTEST_GCC_SUPPRESS_WARNING("-Wold-style-cast")
3090
DOCTEST_GCC_SUPPRESS_WARNING("-Wunused-function")
3091
DOCTEST_GCC_SUPPRESS_WARNING("-Wmultiple-inheritance")
3092
DOCTEST_GCC_SUPPRESS_WARNING("-Wsuggest-attribute")
3093

3094
DOCTEST_MSVC_SUPPRESS_WARNING_PUSH
3095
DOCTEST_MSVC_SUPPRESS_WARNING(4267) // 'var' : conversion from 'x' to 'y', possible loss of data
3096
DOCTEST_MSVC_SUPPRESS_WARNING(4530) // C++ exception handler used, but unwind semantics not enabled
3097
DOCTEST_MSVC_SUPPRESS_WARNING(4577) // 'noexcept' used with no exception handling mode specified
3098
DOCTEST_MSVC_SUPPRESS_WARNING(4774) // format string expected in argument is not a string literal
3099
DOCTEST_MSVC_SUPPRESS_WARNING(4365) // conversion from 'int' to 'unsigned', signed/unsigned mismatch
3100
DOCTEST_MSVC_SUPPRESS_WARNING(5039) // pointer to potentially throwing function passed to extern C
3101
DOCTEST_MSVC_SUPPRESS_WARNING(4800) // forcing value to bool 'true' or 'false' (performance warning)
3102
DOCTEST_MSVC_SUPPRESS_WARNING(5245) // unreferenced function with internal linkage has been removed
3103

3104
DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_BEGIN
3105

3106
// required includes - will go only in one translation unit!
3107
#include <ctime>
3108
#include <cmath>
3109
#include <climits>
3110
// borland (Embarcadero) compiler requires math.h and not cmath - https://github.com/doctest/doctest/pull/37
3111
#ifdef __BORLANDC__
3112
#include <math.h>
3113
#endif // __BORLANDC__
3114
#include <new>
3115
#include <cstdio>
3116
#include <cstdlib>
3117
#include <cstring>
3118
#include <limits>
3119
#include <utility>
3120
#include <fstream>
3121
#include <sstream>
3122
#include <iostream>
3123
#include <algorithm>
3124
#include <iomanip>
3125
#include <vector>
3126
#ifndef DOCTEST_CONFIG_NO_MULTITHREADING
3127
#include <atomic>
3128
#include <mutex>
3129
#define DOCTEST_DECLARE_MUTEX(name) std::mutex name;
3130
#define DOCTEST_DECLARE_STATIC_MUTEX(name) static DOCTEST_DECLARE_MUTEX(name)
3131
#define DOCTEST_LOCK_MUTEX(name) std::lock_guard<std::mutex> DOCTEST_ANONYMOUS(DOCTEST_ANON_LOCK_)(name);
3132
#else // DOCTEST_CONFIG_NO_MULTITHREADING
3133
#define DOCTEST_DECLARE_MUTEX(name)
3134
#define DOCTEST_DECLARE_STATIC_MUTEX(name)
3135
#define DOCTEST_LOCK_MUTEX(name)
3136
#endif // DOCTEST_CONFIG_NO_MULTITHREADING
3137
#include <set>
3138
#include <map>
3139
#include <unordered_set>
3140
#include <exception>
3141
#include <stdexcept>
3142

3143
#if !defined(DOCTEST_CONFIG_NO_POSIX_SIGNALS)
3144
#include <csignal>
3145
#endif
3146

3147
#include <cfloat>
3148
#include <cctype>
3149
#include <cstdint>
3150
#include <string>
3151

3152
#ifdef DOCTEST_PLATFORM_MAC
3153
#include <sys/types.h>
3154
#include <unistd.h>
3155
#include <sys/sysctl.h>
3156
#endif // DOCTEST_PLATFORM_MAC
3157

3158
#ifdef DOCTEST_PLATFORM_WINDOWS
3159

3160
// defines for a leaner windows.h
3161
#ifndef WIN32_LEAN_AND_MEAN
3162
#define WIN32_LEAN_AND_MEAN
3163
#endif // WIN32_LEAN_AND_MEAN
3164
#ifndef NOMINMAX
3165
#define NOMINMAX
3166
#endif // NOMINMAX
3167

3168
// not sure what AfxWin.h is for - here I do what Catch does
3169
#ifdef __AFXDLL
3170
#include <AfxWin.h>
3171
#else
3172
#include <windows.h>
3173
#endif
3174
#include <io.h>
3175

3176
#else // DOCTEST_PLATFORM_WINDOWS
3177

3178
#include <sys/time.h>
3179
#include <unistd.h>
3180

3181
#endif // DOCTEST_PLATFORM_WINDOWS
3182

3183
// this is a fix for https://github.com/doctest/doctest/issues/348
3184
// https://mail.gnome.org/archives/xml/2012-January/msg00000.html
3185
#if !defined(HAVE_UNISTD_H) && !defined(STDOUT_FILENO)
3186
#define STDOUT_FILENO fileno(stdout)
3187
#endif // HAVE_UNISTD_H
3188

3189
DOCTEST_MAKE_STD_HEADERS_CLEAN_FROM_WARNINGS_ON_WALL_END
3190

3191
// counts the number of elements in a C array
3192
#define DOCTEST_COUNTOF(x) (sizeof(x) / sizeof(x[0]))
3193

3194
#ifdef DOCTEST_CONFIG_DISABLE
3195
#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_disabled
3196
#else // DOCTEST_CONFIG_DISABLE
3197
#define DOCTEST_BRANCH_ON_DISABLED(if_disabled, if_not_disabled) if_not_disabled
3198
#endif // DOCTEST_CONFIG_DISABLE
3199

3200
#ifndef DOCTEST_CONFIG_OPTIONS_PREFIX
3201
#define DOCTEST_CONFIG_OPTIONS_PREFIX "dt-"
3202
#endif
3203

3204
#ifndef DOCTEST_THREAD_LOCAL
3205
#if defined(DOCTEST_CONFIG_NO_MULTITHREADING) || DOCTEST_MSVC && (DOCTEST_MSVC < DOCTEST_COMPILER(19, 0, 0))
3206
#define DOCTEST_THREAD_LOCAL
3207
#else // DOCTEST_MSVC
3208
#define DOCTEST_THREAD_LOCAL thread_local
3209
#endif // DOCTEST_MSVC
3210
#endif // DOCTEST_THREAD_LOCAL
3211

3212
#ifndef DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES
3213
#define DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES 32
3214
#endif
3215

3216
#ifndef DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE
3217
#define DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE 64
3218
#endif
3219

3220
#ifdef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
3221
#define DOCTEST_OPTIONS_PREFIX_DISPLAY DOCTEST_CONFIG_OPTIONS_PREFIX
3222
#else
3223
#define DOCTEST_OPTIONS_PREFIX_DISPLAY ""
3224
#endif
3225

3226
#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
3227
#define DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
3228
#endif
3229

3230
#ifndef DOCTEST_CDECL
3231
#define DOCTEST_CDECL __cdecl
3232
#endif
3233

3234
namespace doctest {
3235

3236
bool is_running_in_test = false;
3237

3238
namespace {
3239
    using namespace detail;
3240

3241
    template <typename Ex>
3242
    DOCTEST_NORETURN void throw_exception(Ex const& e) {
3243
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
3244
        throw e;
3245
#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
3246
        std::cerr << "doctest will terminate because it needed to throw an exception.\n"
3247
                  << "The message was: " << e.what() << '\n';
3248
        std::terminate();
3249
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
3250
    }
3251

3252
#ifndef DOCTEST_INTERNAL_ERROR
3253
#define DOCTEST_INTERNAL_ERROR(msg)                                                                \
3254
    throw_exception(std::logic_error(                                                              \
3255
            __FILE__ ":" DOCTEST_TOSTR(__LINE__) ": Internal doctest error: " msg))
3256
#endif // DOCTEST_INTERNAL_ERROR
3257

3258
    // case insensitive strcmp
3259
    int stricmp(const char* a, const char* b) {
3260
        for(;; a++, b++) {
3261
            const int d = tolower(*a) - tolower(*b);
3262
            if(d != 0 || !*a)
3263
                return d;
3264
        }
3265
    }
3266

3267
    struct Endianness
3268
    {
3269
        enum Arch
3270
        {
3271
            Big,
3272
            Little
3273
        };
3274

3275
        static Arch which() {
3276
            int x = 1;
3277
            // casting any data pointer to char* is allowed
3278
            auto ptr = reinterpret_cast<char*>(&x);
3279
            if(*ptr)
3280
                return Little;
3281
            return Big;
3282
        }
3283
    };
3284
} // namespace
3285

3286
namespace detail {
3287
    DOCTEST_THREAD_LOCAL class
3288
    {
3289
        std::vector<std::streampos> stack;
3290
        std::stringstream           ss;
3291

3292
    public:
3293
        std::ostream* push() {
3294
            stack.push_back(ss.tellp());
3295
            return &ss;
3296
        }
3297

3298
        String pop() {
3299
            if (stack.empty())
3300
                DOCTEST_INTERNAL_ERROR("TLSS was empty when trying to pop!");
3301

3302
            std::streampos pos = stack.back();
3303
            stack.pop_back();
3304
            unsigned sz = static_cast<unsigned>(ss.tellp() - pos);
3305
            ss.rdbuf()->pubseekpos(pos, std::ios::in | std::ios::out);
3306
            return String(ss, sz);
3307
        }
3308
    } g_oss;
3309

3310
    std::ostream* tlssPush() {
3311
        return g_oss.push();
3312
    }
3313

3314
    String tlssPop() {
3315
        return g_oss.pop();
3316
    }
3317

3318
#ifndef DOCTEST_CONFIG_DISABLE
3319

3320
namespace timer_large_integer
3321
{
3322

3323
#if defined(DOCTEST_PLATFORM_WINDOWS)
3324
    using type = ULONGLONG;
3325
#else // DOCTEST_PLATFORM_WINDOWS
3326
    using type = std::uint64_t;
3327
#endif // DOCTEST_PLATFORM_WINDOWS
3328
}
3329

3330
using ticks_t = timer_large_integer::type;
3331

3332
#ifdef DOCTEST_CONFIG_GETCURRENTTICKS
3333
    ticks_t getCurrentTicks() { return DOCTEST_CONFIG_GETCURRENTTICKS(); }
3334
#elif defined(DOCTEST_PLATFORM_WINDOWS)
3335
    ticks_t getCurrentTicks() {
3336
        static LARGE_INTEGER hz = { {0} }, hzo = { {0} };
3337
        if(!hz.QuadPart) {
3338
            QueryPerformanceFrequency(&hz);
3339
            QueryPerformanceCounter(&hzo);
3340
        }
3341
        LARGE_INTEGER t;
3342
        QueryPerformanceCounter(&t);
3343
        return ((t.QuadPart - hzo.QuadPart) * LONGLONG(1000000)) / hz.QuadPart;
3344
    }
3345
#else  // DOCTEST_PLATFORM_WINDOWS
3346
    ticks_t getCurrentTicks() {
3347
        timeval t;
3348
        gettimeofday(&t, nullptr);
3349
        return static_cast<ticks_t>(t.tv_sec) * 1000000 + static_cast<ticks_t>(t.tv_usec);
3350
    }
3351
#endif // DOCTEST_PLATFORM_WINDOWS
3352

3353
    struct Timer
3354
    {
3355
        void         start() { m_ticks = getCurrentTicks(); }
3356
        unsigned int getElapsedMicroseconds() const {
3357
            return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
3358
        }
3359
        //unsigned int getElapsedMilliseconds() const {
3360
        //    return static_cast<unsigned int>(getElapsedMicroseconds() / 1000);
3361
        //}
3362
        double getElapsedSeconds() const { return static_cast<double>(getCurrentTicks() - m_ticks) / 1000000.0; }
3363

3364
    private:
3365
        ticks_t m_ticks = 0;
3366
    };
3367

3368
#ifdef DOCTEST_CONFIG_NO_MULTITHREADING
3369
    template <typename T>
3370
    using Atomic = T;
3371
#else // DOCTEST_CONFIG_NO_MULTITHREADING
3372
    template <typename T>
3373
    using Atomic = std::atomic<T>;
3374
#endif // DOCTEST_CONFIG_NO_MULTITHREADING
3375

3376
#if defined(DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS) || defined(DOCTEST_CONFIG_NO_MULTITHREADING)
3377
    template <typename T>
3378
    using MultiLaneAtomic = Atomic<T>;
3379
#else // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
3380
    // Provides a multilane implementation of an atomic variable that supports add, sub, load,
3381
    // store. Instead of using a single atomic variable, this splits up into multiple ones,
3382
    // each sitting on a separate cache line. The goal is to provide a speedup when most
3383
    // operations are modifying. It achieves this with two properties:
3384
    //
3385
    // * Multiple atomics are used, so chance of congestion from the same atomic is reduced.
3386
    // * Each atomic sits on a separate cache line, so false sharing is reduced.
3387
    //
3388
    // The disadvantage is that there is a small overhead due to the use of TLS, and load/store
3389
    // is slower because all atomics have to be accessed.
3390
    template <typename T>
3391
    class MultiLaneAtomic
3392
    {
3393
        struct CacheLineAlignedAtomic
3394
        {
3395
            Atomic<T> atomic{};
3396
            char padding[DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE - sizeof(Atomic<T>)];
3397
        };
3398
        CacheLineAlignedAtomic m_atomics[DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES];
3399

3400
        static_assert(sizeof(CacheLineAlignedAtomic) == DOCTEST_MULTI_LANE_ATOMICS_CACHE_LINE_SIZE,
3401
                      "guarantee one atomic takes exactly one cache line");
3402

3403
    public:
3404
        T operator++() DOCTEST_NOEXCEPT { return fetch_add(1) + 1; }
3405

3406
        T operator++(int) DOCTEST_NOEXCEPT { return fetch_add(1); }
3407

3408
        T fetch_add(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
3409
            return myAtomic().fetch_add(arg, order);
3410
        }
3411

3412
        T fetch_sub(T arg, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
3413
            return myAtomic().fetch_sub(arg, order);
3414
        }
3415

3416
        operator T() const DOCTEST_NOEXCEPT { return load(); }
3417

3418
        T load(std::memory_order order = std::memory_order_seq_cst) const DOCTEST_NOEXCEPT {
3419
            auto result = T();
3420
            for(auto const& c : m_atomics) {
3421
                result += c.atomic.load(order);
3422
            }
3423
            return result;
3424
        }
3425

3426
        T operator=(T desired) DOCTEST_NOEXCEPT { // lgtm [cpp/assignment-does-not-return-this]
3427
            store(desired);
3428
            return desired;
3429
        }
3430

3431
        void store(T desired, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
3432
            // first value becomes desired", all others become 0.
3433
            for(auto& c : m_atomics) {
3434
                c.atomic.store(desired, order);
3435
                desired = {};
3436
            }
3437
        }
3438

3439
    private:
3440
        // Each thread has a different atomic that it operates on. If more than NumLanes threads
3441
        // use this, some will use the same atomic. So performance will degrade a bit, but still
3442
        // everything will work.
3443
        //
3444
        // The logic here is a bit tricky. The call should be as fast as possible, so that there
3445
        // is minimal to no overhead in determining the correct atomic for the current thread.
3446
        //
3447
        // 1. A global static counter laneCounter counts continuously up.
3448
        // 2. Each successive thread will use modulo operation of that counter so it gets an atomic
3449
        //    assigned in a round-robin fashion.
3450
        // 3. This tlsLaneIdx is stored in the thread local data, so it is directly available with
3451
        //    little overhead.
3452
        Atomic<T>& myAtomic() DOCTEST_NOEXCEPT {
3453
            static Atomic<size_t> laneCounter;
3454
            DOCTEST_THREAD_LOCAL size_t tlsLaneIdx =
3455
                    laneCounter++ % DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES;
3456

3457
            return m_atomics[tlsLaneIdx].atomic;
3458
        }
3459
    };
3460
#endif // DOCTEST_CONFIG_NO_MULTI_LANE_ATOMICS
3461

3462
    // this holds both parameters from the command line and runtime data for tests
3463
    struct ContextState : ContextOptions, TestRunStats, CurrentTestCaseStats
3464
    {
3465
        MultiLaneAtomic<int> numAssertsCurrentTest_atomic;
3466
        MultiLaneAtomic<int> numAssertsFailedCurrentTest_atomic;
3467

3468
        std::vector<std::vector<String>> filters = decltype(filters)(10); // 10 different filters
3469

3470
        std::vector<IReporter*> reporters_currently_used;
3471

3472
        assert_handler ah = nullptr;
3473

3474
        Timer timer;
3475

3476
        std::vector<String> stringifiedContexts; // logging from INFO() due to an exception
3477

3478
        // stuff for subcases
3479
        bool reachedLeaf;
3480
        std::vector<SubcaseSignature> subcaseStack;
3481
        std::vector<SubcaseSignature> nextSubcaseStack;
3482
        std::unordered_set<unsigned long long> fullyTraversedSubcases;
3483
        size_t currentSubcaseDepth;
3484
        Atomic<bool> shouldLogCurrentException;
3485

3486
        void resetRunData() {
3487
            numTestCases                = 0;
3488
            numTestCasesPassingFilters  = 0;
3489
            numTestSuitesPassingFilters = 0;
3490
            numTestCasesFailed          = 0;
3491
            numAsserts                  = 0;
3492
            numAssertsFailed            = 0;
3493
            numAssertsCurrentTest       = 0;
3494
            numAssertsFailedCurrentTest = 0;
3495
        }
3496

3497
        void finalizeTestCaseData() {
3498
            seconds = timer.getElapsedSeconds();
3499

3500
            // update the non-atomic counters
3501
            numAsserts += numAssertsCurrentTest_atomic;
3502
            numAssertsFailed += numAssertsFailedCurrentTest_atomic;
3503
            numAssertsCurrentTest       = numAssertsCurrentTest_atomic;
3504
            numAssertsFailedCurrentTest = numAssertsFailedCurrentTest_atomic;
3505

3506
            if(numAssertsFailedCurrentTest)
3507
                failure_flags |= TestCaseFailureReason::AssertFailure;
3508

3509
            if(Approx(currentTest->m_timeout).epsilon(DBL_EPSILON) != 0 &&
3510
               Approx(seconds).epsilon(DBL_EPSILON) > currentTest->m_timeout)
3511
                failure_flags |= TestCaseFailureReason::Timeout;
3512

3513
            if(currentTest->m_should_fail) {
3514
                if(failure_flags) {
3515
                    failure_flags |= TestCaseFailureReason::ShouldHaveFailedAndDid;
3516
                } else {
3517
                    failure_flags |= TestCaseFailureReason::ShouldHaveFailedButDidnt;
3518
                }
3519
            } else if(failure_flags && currentTest->m_may_fail) {
3520
                failure_flags |= TestCaseFailureReason::CouldHaveFailedAndDid;
3521
            } else if(currentTest->m_expected_failures > 0) {
3522
                if(numAssertsFailedCurrentTest == currentTest->m_expected_failures) {
3523
                    failure_flags |= TestCaseFailureReason::FailedExactlyNumTimes;
3524
                } else {
3525
                    failure_flags |= TestCaseFailureReason::DidntFailExactlyNumTimes;
3526
                }
3527
            }
3528

3529
            bool ok_to_fail = (TestCaseFailureReason::ShouldHaveFailedAndDid & failure_flags) ||
3530
                              (TestCaseFailureReason::CouldHaveFailedAndDid & failure_flags) ||
3531
                              (TestCaseFailureReason::FailedExactlyNumTimes & failure_flags);
3532

3533
            // if any subcase has failed - the whole test case has failed
3534
            testCaseSuccess = !(failure_flags && !ok_to_fail);
3535
            if(!testCaseSuccess)
3536
                numTestCasesFailed++;
3537
        }
3538
    };
3539

3540
    ContextState* g_cs = nullptr;
3541

3542
    // used to avoid locks for the debug output
3543
    // TODO: figure out if this is indeed necessary/correct - seems like either there still
3544
    // could be a race or that there wouldn't be a race even if using the context directly
3545
    DOCTEST_THREAD_LOCAL bool g_no_colors;
3546

3547
#endif // DOCTEST_CONFIG_DISABLE
3548
} // namespace detail
3549

3550
char* String::allocate(size_type sz) {
3551
    if (sz <= last) {
3552
        buf[sz] = '\0';
3553
        setLast(last - sz);
3554
        return buf;
3555
    } else {
3556
        setOnHeap();
3557
        data.size = sz;
3558
        data.capacity = data.size + 1;
3559
        data.ptr = new char[data.capacity];
3560
        data.ptr[sz] = '\0';
3561
        return data.ptr;
3562
    }
3563
}
3564

3565
void String::setOnHeap() noexcept { *reinterpret_cast<unsigned char*>(&buf[last]) = 128; }
3566
void String::setLast(size_type in) noexcept { buf[last] = char(in); }
3567
void String::setSize(size_type sz) noexcept {
3568
    if (isOnStack()) { buf[sz] = '\0'; setLast(last - sz); }
3569
    else { data.ptr[sz] = '\0'; data.size = sz; }
3570
}
3571

3572
void String::copy(const String& other) {
3573
    if(other.isOnStack()) {
3574
        memcpy(buf, other.buf, len);
3575
    } else {
3576
        memcpy(allocate(other.data.size), other.data.ptr, other.data.size);
3577
    }
3578
}
3579

3580
String::String() noexcept {
3581
    buf[0] = '\0';
3582
    setLast();
3583
}
3584

3585
String::~String() {
3586
    if(!isOnStack())
3587
        delete[] data.ptr;
3588
} // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
3589

3590
String::String(const char* in)
3591
        : String(in, strlen(in)) {}
3592

3593
String::String(const char* in, size_type in_size) {
3594
    memcpy(allocate(in_size), in, in_size);
3595
}
3596

3597
String::String(std::istream& in, size_type in_size) {
3598
    in.read(allocate(in_size), in_size);
3599
}
3600

3601
String::String(const String& other) { copy(other); }
3602

3603
String& String::operator=(const String& other) {
3604
    if(this != &other) {
3605
        if(!isOnStack())
3606
            delete[] data.ptr;
3607

3608
        copy(other);
3609
    }
3610

3611
    return *this;
3612
}
3613

3614
String& String::operator+=(const String& other) {
3615
    const size_type my_old_size = size();
3616
    const size_type other_size  = other.size();
3617
    const size_type total_size  = my_old_size + other_size;
3618
    if(isOnStack()) {
3619
        if(total_size < len) {
3620
            // append to the current stack space
3621
            memcpy(buf + my_old_size, other.c_str(), other_size + 1);
3622
            // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
3623
            setLast(last - total_size);
3624
        } else {
3625
            // alloc new chunk
3626
            char* temp = new char[total_size + 1];
3627
            // copy current data to new location before writing in the union
3628
            memcpy(temp, buf, my_old_size); // skip the +1 ('\0') for speed
3629
            // update data in union
3630
            setOnHeap();
3631
            data.size     = total_size;
3632
            data.capacity = data.size + 1;
3633
            data.ptr      = temp;
3634
            // transfer the rest of the data
3635
            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
3636
        }
3637
    } else {
3638
        if(data.capacity > total_size) {
3639
            // append to the current heap block
3640
            data.size = total_size;
3641
            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
3642
        } else {
3643
            // resize
3644
            data.capacity *= 2;
3645
            if(data.capacity <= total_size)
3646
                data.capacity = total_size + 1;
3647
            // alloc new chunk
3648
            char* temp = new char[data.capacity];
3649
            // copy current data to new location before releasing it
3650
            memcpy(temp, data.ptr, my_old_size); // skip the +1 ('\0') for speed
3651
            // release old chunk
3652
            delete[] data.ptr;
3653
            // update the rest of the union members
3654
            data.size = total_size;
3655
            data.ptr  = temp;
3656
            // transfer the rest of the data
3657
            memcpy(data.ptr + my_old_size, other.c_str(), other_size + 1);
3658
        }
3659
    }
3660

3661
    return *this;
3662
}
3663

3664
String::String(String&& other) noexcept {
3665
    memcpy(buf, other.buf, len);
3666
    other.buf[0] = '\0';
3667
    other.setLast();
3668
}
3669

3670
String& String::operator=(String&& other) noexcept {
3671
    if(this != &other) {
3672
        if(!isOnStack())
3673
            delete[] data.ptr;
3674
        memcpy(buf, other.buf, len);
3675
        other.buf[0] = '\0';
3676
        other.setLast();
3677
    }
3678
    return *this;
3679
}
3680

3681
char String::operator[](size_type i) const {
3682
    return const_cast<String*>(this)->operator[](i);
3683
}
3684

3685
char& String::operator[](size_type i) {
3686
    if(isOnStack())
3687
        return reinterpret_cast<char*>(buf)[i];
3688
    return data.ptr[i];
3689
}
3690

3691
DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wmaybe-uninitialized")
3692
String::size_type String::size() const {
3693
    if(isOnStack())
3694
        return last - (size_type(buf[last]) & 31); // using "last" would work only if "len" is 32
3695
    return data.size;
3696
}
3697
DOCTEST_GCC_SUPPRESS_WARNING_POP
3698

3699
String::size_type String::capacity() const {
3700
    if(isOnStack())
3701
        return len;
3702
    return data.capacity;
3703
}
3704

3705
String String::substr(size_type pos, size_type cnt) && {
3706
    cnt = std::min(cnt, size() - 1 - pos);
3707
    char* cptr = c_str();
3708
    memmove(cptr, cptr + pos, cnt);
3709
    setSize(cnt);
3710
    return std::move(*this);
3711
}
3712

3713
String String::substr(size_type pos, size_type cnt) const & {
3714
    cnt = std::min(cnt, size() - 1 - pos);
3715
    return String{ c_str() + pos, cnt };
3716
}
3717

3718
String::size_type String::find(char ch, size_type pos) const {
3719
    const char* begin = c_str();
3720
    const char* end = begin + size();
3721
    const char* it = begin + pos;
3722
    for (; it < end && *it != ch; it++);
3723
    if (it < end) { return static_cast<size_type>(it - begin); }
3724
    else { return npos; }
3725
}
3726

3727
String::size_type String::rfind(char ch, size_type pos) const {
3728
    const char* begin = c_str();
3729
    const char* it = begin + std::min(pos, size() - 1);
3730
    for (; it >= begin && *it != ch; it--);
3731
    if (it >= begin) { return static_cast<size_type>(it - begin); }
3732
    else { return npos; }
3733
}
3734

3735
int String::compare(const char* other, bool no_case) const {
3736
    if(no_case)
3737
        return doctest::stricmp(c_str(), other);
3738
    return std::strcmp(c_str(), other);
3739
}
3740

3741
int String::compare(const String& other, bool no_case) const {
3742
    return compare(other.c_str(), no_case);
3743
}
3744

3745
String operator+(const String& lhs, const String& rhs) { return  String(lhs) += rhs; }
3746

3747
bool operator==(const String& lhs, const String& rhs) { return lhs.compare(rhs) == 0; }
3748
bool operator!=(const String& lhs, const String& rhs) { return lhs.compare(rhs) != 0; }
3749
bool operator< (const String& lhs, const String& rhs) { return lhs.compare(rhs) < 0; }
3750
bool operator> (const String& lhs, const String& rhs) { return lhs.compare(rhs) > 0; }
3751
bool operator<=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) < 0 : true; }
3752
bool operator>=(const String& lhs, const String& rhs) { return (lhs != rhs) ? lhs.compare(rhs) > 0 : true; }
3753

3754
std::ostream& operator<<(std::ostream& s, const String& in) { return s << in.c_str(); }
3755

3756
Contains::Contains(const String& str) : string(str) { }
3757

3758
bool Contains::checkWith(const String& other) const {
3759
    return strstr(other.c_str(), string.c_str()) != nullptr;
3760
}
3761

3762
String toString(const Contains& in) {
3763
    return "Contains( " + in.string + " )";
3764
}
3765

3766
bool operator==(const String& lhs, const Contains& rhs) { return rhs.checkWith(lhs); }
3767
bool operator==(const Contains& lhs, const String& rhs) { return lhs.checkWith(rhs); }
3768
bool operator!=(const String& lhs, const Contains& rhs) { return !rhs.checkWith(lhs); }
3769
bool operator!=(const Contains& lhs, const String& rhs) { return !lhs.checkWith(rhs); }
3770

3771
namespace {
3772
    void color_to_stream(std::ostream&, Color::Enum) DOCTEST_BRANCH_ON_DISABLED({}, ;)
3773
} // namespace
3774

3775
namespace Color {
3776
    std::ostream& operator<<(std::ostream& s, Color::Enum code) {
3777
        color_to_stream(s, code);
3778
        return s;
3779
    }
3780
} // namespace Color
3781

3782
// clang-format off
3783
const char* assertString(assertType::Enum at) {
3784
    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4061) // enum 'x' in switch of enum 'y' is not explicitely handled
3785
    #define DOCTEST_GENERATE_ASSERT_TYPE_CASE(assert_type) case assertType::DT_ ## assert_type: return #assert_type
3786
    #define DOCTEST_GENERATE_ASSERT_TYPE_CASES(assert_type) \
3787
        DOCTEST_GENERATE_ASSERT_TYPE_CASE(WARN_ ## assert_type); \
3788
        DOCTEST_GENERATE_ASSERT_TYPE_CASE(CHECK_ ## assert_type); \
3789
        DOCTEST_GENERATE_ASSERT_TYPE_CASE(REQUIRE_ ## assert_type)
3790
    switch(at) {
3791
        DOCTEST_GENERATE_ASSERT_TYPE_CASE(WARN);
3792
        DOCTEST_GENERATE_ASSERT_TYPE_CASE(CHECK);
3793
        DOCTEST_GENERATE_ASSERT_TYPE_CASE(REQUIRE);
3794

3795
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(FALSE);
3796

3797
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS);
3798

3799
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_AS);
3800

3801
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_WITH);
3802

3803
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(THROWS_WITH_AS);
3804

3805
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(NOTHROW);
3806

3807
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(EQ);
3808
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(NE);
3809
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(GT);
3810
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(LT);
3811
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(GE);
3812
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(LE);
3813

3814
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(UNARY);
3815
        DOCTEST_GENERATE_ASSERT_TYPE_CASES(UNARY_FALSE);
3816

3817
        default: DOCTEST_INTERNAL_ERROR("Tried stringifying invalid assert type!");
3818
    }
3819
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
3820
}
3821
// clang-format on
3822

3823
const char* failureString(assertType::Enum at) {
3824
    if(at & assertType::is_warn) //!OCLINT bitwise operator in conditional
3825
        return "WARNING";
3826
    if(at & assertType::is_check) //!OCLINT bitwise operator in conditional
3827
        return "ERROR";
3828
    if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
3829
        return "FATAL ERROR";
3830
    return "";
3831
}
3832

3833
DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
3834
DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wnull-dereference")
3835
// depending on the current options this will remove the path of filenames
3836
const char* skipPathFromFilename(const char* file) {
3837
#ifndef DOCTEST_CONFIG_DISABLE
3838
    if(getContextOptions()->no_path_in_filenames) {
3839
        auto back    = std::strrchr(file, '\\');
3840
        auto forward = std::strrchr(file, '/');
3841
        if(back || forward) {
3842
            if(back > forward)
3843
                forward = back;
3844
            return forward + 1;
3845
        }
3846
    }
3847
#endif // DOCTEST_CONFIG_DISABLE
3848
    return file;
3849
}
3850
DOCTEST_CLANG_SUPPRESS_WARNING_POP
3851
DOCTEST_GCC_SUPPRESS_WARNING_POP
3852

3853
bool SubcaseSignature::operator==(const SubcaseSignature& other) const {
3854
    return m_line == other.m_line
3855
        && std::strcmp(m_file, other.m_file) == 0
3856
        && m_name == other.m_name;
3857
}
3858

3859
bool SubcaseSignature::operator<(const SubcaseSignature& other) const {
3860
    if(m_line != other.m_line)
3861
        return m_line < other.m_line;
3862
    if(std::strcmp(m_file, other.m_file) != 0)
3863
        return std::strcmp(m_file, other.m_file) < 0;
3864
    return m_name.compare(other.m_name) < 0;
3865
}
3866

3867
DOCTEST_DEFINE_INTERFACE(IContextScope)
3868

3869
namespace detail {
3870
    void filldata<const void*>::fill(std::ostream* stream, const void* in) {
3871
        if (in) { *stream << in; }
3872
        else { *stream << "nullptr"; }
3873
    }
3874

3875
    template <typename T>
3876
    String toStreamLit(T t) {
3877
        std::ostream* os = tlssPush();
3878
        os->operator<<(t);
3879
        return tlssPop();
3880
    }
3881
}
3882

3883
#ifdef DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
3884
String toString(const char* in) { return String("\"") + (in ? in : "{null string}") + "\""; }
3885
#endif // DOCTEST_CONFIG_TREAT_CHAR_STAR_AS_STRING
3886

3887
#if DOCTEST_MSVC >= DOCTEST_COMPILER(19, 20, 0)
3888
// see this issue on why this is needed: https://github.com/doctest/doctest/issues/183
3889
String toString(const std::string& in) { return in.c_str(); }
3890
#endif // VS 2019
3891

3892
String toString(String in) { return in; }
3893

3894
String toString(std::nullptr_t) { return "nullptr"; }
3895

3896
String toString(bool in) { return in ? "true" : "false"; }
3897

3898
String toString(float in) { return toStreamLit(in); }
3899
String toString(double in) { return toStreamLit(in); }
3900
String toString(double long in) { return toStreamLit(in); }
3901

3902
String toString(char in) { return toStreamLit(static_cast<signed>(in)); }
3903
String toString(char signed in) { return toStreamLit(static_cast<signed>(in)); }
3904
String toString(char unsigned in) { return toStreamLit(static_cast<unsigned>(in)); }
3905
String toString(short in) { return toStreamLit(in); }
3906
String toString(short unsigned in) { return toStreamLit(in); }
3907
String toString(signed in) { return toStreamLit(in); }
3908
String toString(unsigned in) { return toStreamLit(in); }
3909
String toString(long in) { return toStreamLit(in); }
3910
String toString(long unsigned in) { return toStreamLit(in); }
3911
String toString(long long in) { return toStreamLit(in); }
3912
String toString(long long unsigned in) { return toStreamLit(in); }
3913

3914
Approx::Approx(double value)
3915
        : m_epsilon(static_cast<double>(std::numeric_limits<float>::epsilon()) * 100)
3916
        , m_scale(1.0)
3917
        , m_value(value) {}
3918

3919
Approx Approx::operator()(double value) const {
3920
    Approx approx(value);
3921
    approx.epsilon(m_epsilon);
3922
    approx.scale(m_scale);
3923
    return approx;
3924
}
3925

3926
Approx& Approx::epsilon(double newEpsilon) {
3927
    m_epsilon = newEpsilon;
3928
    return *this;
3929
}
3930
Approx& Approx::scale(double newScale) {
3931
    m_scale = newScale;
3932
    return *this;
3933
}
3934

3935
bool operator==(double lhs, const Approx& rhs) {
3936
    // Thanks to Richard Harris for his help refining this formula
3937
    return std::fabs(lhs - rhs.m_value) <
3938
           rhs.m_epsilon * (rhs.m_scale + std::max<double>(std::fabs(lhs), std::fabs(rhs.m_value)));
3939
}
3940
bool operator==(const Approx& lhs, double rhs) { return operator==(rhs, lhs); }
3941
bool operator!=(double lhs, const Approx& rhs) { return !operator==(lhs, rhs); }
3942
bool operator!=(const Approx& lhs, double rhs) { return !operator==(rhs, lhs); }
3943
bool operator<=(double lhs, const Approx& rhs) { return lhs < rhs.m_value || lhs == rhs; }
3944
bool operator<=(const Approx& lhs, double rhs) { return lhs.m_value < rhs || lhs == rhs; }
3945
bool operator>=(double lhs, const Approx& rhs) { return lhs > rhs.m_value || lhs == rhs; }
3946
bool operator>=(const Approx& lhs, double rhs) { return lhs.m_value > rhs || lhs == rhs; }
3947
bool operator<(double lhs, const Approx& rhs) { return lhs < rhs.m_value && lhs != rhs; }
3948
bool operator<(const Approx& lhs, double rhs) { return lhs.m_value < rhs && lhs != rhs; }
3949
bool operator>(double lhs, const Approx& rhs) { return lhs > rhs.m_value && lhs != rhs; }
3950
bool operator>(const Approx& lhs, double rhs) { return lhs.m_value > rhs && lhs != rhs; }
3951

3952
String toString(const Approx& in) {
3953
    return "Approx( " + doctest::toString(in.m_value) + " )";
3954
}
3955
const ContextOptions* getContextOptions() { return DOCTEST_BRANCH_ON_DISABLED(nullptr, g_cs); }
3956

3957
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4738)
3958
template <typename F>
3959
IsNaN<F>::operator bool() const {
3960
    return std::isnan(value) ^ flipped;
3961
}
3962
DOCTEST_MSVC_SUPPRESS_WARNING_POP
3963
template struct DOCTEST_INTERFACE_DEF IsNaN<float>;
3964
template struct DOCTEST_INTERFACE_DEF IsNaN<double>;
3965
template struct DOCTEST_INTERFACE_DEF IsNaN<long double>;
3966
template <typename F>
3967
String toString(IsNaN<F> in) { return String(in.flipped ? "! " : "") + "IsNaN( " + doctest::toString(in.value) + " )"; }
3968
String toString(IsNaN<float> in) { return toString<float>(in); }
3969
String toString(IsNaN<double> in) { return toString<double>(in); }
3970
String toString(IsNaN<double long> in) { return toString<double long>(in); }
3971

3972
} // namespace doctest
3973

3974
#ifdef DOCTEST_CONFIG_DISABLE
3975
namespace doctest {
3976
Context::Context(int, const char* const*) {}
3977
Context::~Context() = default;
3978
void Context::applyCommandLine(int, const char* const*) {}
3979
void Context::addFilter(const char*, const char*) {}
3980
void Context::clearFilters() {}
3981
void Context::setOption(const char*, bool) {}
3982
void Context::setOption(const char*, int) {}
3983
void Context::setOption(const char*, const char*) {}
3984
bool Context::shouldExit() { return false; }
3985
void Context::setAsDefaultForAssertsOutOfTestCases() {}
3986
void Context::setAssertHandler(detail::assert_handler) {}
3987
void Context::setCout(std::ostream*) {}
3988
int  Context::run() { return 0; }
3989

3990
int                         IReporter::get_num_active_contexts() { return 0; }
3991
const IContextScope* const* IReporter::get_active_contexts() { return nullptr; }
3992
int                         IReporter::get_num_stringified_contexts() { return 0; }
3993
const String*               IReporter::get_stringified_contexts() { return nullptr; }
3994

3995
int registerReporter(const char*, int, IReporter*) { return 0; }
3996

3997
} // namespace doctest
3998
#else // DOCTEST_CONFIG_DISABLE
3999

4000
#if !defined(DOCTEST_CONFIG_COLORS_NONE)
4001
#if !defined(DOCTEST_CONFIG_COLORS_WINDOWS) && !defined(DOCTEST_CONFIG_COLORS_ANSI)
4002
#ifdef DOCTEST_PLATFORM_WINDOWS
4003
#define DOCTEST_CONFIG_COLORS_WINDOWS
4004
#else // linux
4005
#define DOCTEST_CONFIG_COLORS_ANSI
4006
#endif // platform
4007
#endif // DOCTEST_CONFIG_COLORS_WINDOWS && DOCTEST_CONFIG_COLORS_ANSI
4008
#endif // DOCTEST_CONFIG_COLORS_NONE
4009

4010
namespace doctest_detail_test_suite_ns {
4011
// holds the current test suite
4012
doctest::detail::TestSuite& getCurrentTestSuite() {
4013
    static doctest::detail::TestSuite data{};
4014
    return data;
4015
}
4016
} // namespace doctest_detail_test_suite_ns
4017

4018
namespace doctest {
4019
namespace {
4020
    // the int (priority) is part of the key for automatic sorting - sadly one can register a
4021
    // reporter with a duplicate name and a different priority but hopefully that won't happen often :|
4022
    using reporterMap = std::map<std::pair<int, String>, reporterCreatorFunc>;
4023

4024
    reporterMap& getReporters() {
4025
        static reporterMap data;
4026
        return data;
4027
    }
4028
    reporterMap& getListeners() {
4029
        static reporterMap data;
4030
        return data;
4031
    }
4032
} // namespace
4033
namespace detail {
4034
#define DOCTEST_ITERATE_THROUGH_REPORTERS(function, ...)                                           \
4035
    for(auto& curr_rep : g_cs->reporters_currently_used)                                           \
4036
    curr_rep->function(__VA_ARGS__)
4037

4038
    bool checkIfShouldThrow(assertType::Enum at) {
4039
        if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
4040
            return true;
4041

4042
        if((at & assertType::is_check) //!OCLINT bitwise operator in conditional
4043
           && getContextOptions()->abort_after > 0 &&
4044
           (g_cs->numAssertsFailed + g_cs->numAssertsFailedCurrentTest_atomic) >=
4045
                   getContextOptions()->abort_after)
4046
            return true;
4047

4048
        return false;
4049
    }
4050

4051
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
4052
    DOCTEST_NORETURN void throwException() {
4053
        g_cs->shouldLogCurrentException = false;
4054
        throw TestFailureException(); // NOLINT(hicpp-exception-baseclass)
4055
    }
4056
#else // DOCTEST_CONFIG_NO_EXCEPTIONS
4057
    void throwException() {}
4058
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
4059
} // namespace detail
4060

4061
namespace {
4062
    using namespace detail;
4063
    // matching of a string against a wildcard mask (case sensitivity configurable) taken from
4064
    // https://www.codeproject.com/Articles/1088/Wildcard-string-compare-globbing
4065
    int wildcmp(const char* str, const char* wild, bool caseSensitive) {
4066
        const char* cp = str;
4067
        const char* mp = wild;
4068

4069
        while((*str) && (*wild != '*')) {
4070
            if((caseSensitive ? (*wild != *str) : (tolower(*wild) != tolower(*str))) &&
4071
               (*wild != '?')) {
4072
                return 0;
4073
            }
4074
            wild++;
4075
            str++;
4076
        }
4077

4078
        while(*str) {
4079
            if(*wild == '*') {
4080
                if(!*++wild) {
4081
                    return 1;
4082
                }
4083
                mp = wild;
4084
                cp = str + 1;
4085
            } else if((caseSensitive ? (*wild == *str) : (tolower(*wild) == tolower(*str))) ||
4086
                      (*wild == '?')) {
4087
                wild++;
4088
                str++;
4089
            } else {
4090
                wild = mp;   //!OCLINT parameter reassignment
4091
                str  = cp++; //!OCLINT parameter reassignment
4092
            }
4093
        }
4094

4095
        while(*wild == '*') {
4096
            wild++;
4097
        }
4098
        return !*wild;
4099
    }
4100

4101
    // checks if the name matches any of the filters (and can be configured what to do when empty)
4102
    bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty,
4103
        bool caseSensitive) {
4104
        if (filters.empty() && matchEmpty)
4105
            return true;
4106
        for (auto& curr : filters)
4107
            if (wildcmp(name, curr.c_str(), caseSensitive))
4108
                return true;
4109
        return false;
4110
    }
4111

4112
    unsigned long long hash(unsigned long long a, unsigned long long b) {
4113
        return (a << 5) + b;
4114
    }
4115

4116
    // C string hash function (djb2) - taken from http://www.cse.yorku.ca/~oz/hash.html
4117
    unsigned long long hash(const char* str) {
4118
        unsigned long long hash = 5381;
4119
        char c;
4120
        while ((c = *str++))
4121
            hash = ((hash << 5) + hash) + c; // hash * 33 + c
4122
        return hash;
4123
    }
4124

4125
    unsigned long long hash(const SubcaseSignature& sig) {
4126
        return hash(hash(hash(sig.m_file), hash(sig.m_name.c_str())), sig.m_line);
4127
    }
4128

4129
    unsigned long long hash(const std::vector<SubcaseSignature>& sigs, size_t count) {
4130
        unsigned long long running = 0;
4131
        auto end = sigs.begin() + count;
4132
        for (auto it = sigs.begin(); it != end; it++) {
4133
            running = hash(running, hash(*it));
4134
        }
4135
        return running;
4136
    }
4137

4138
    unsigned long long hash(const std::vector<SubcaseSignature>& sigs) {
4139
        unsigned long long running = 0;
4140
        for (const SubcaseSignature& sig : sigs) {
4141
            running = hash(running, hash(sig));
4142
        }
4143
        return running;
4144
    }
4145
} // namespace
4146
namespace detail {
4147
    bool Subcase::checkFilters() {
4148
        if (g_cs->subcaseStack.size() < size_t(g_cs->subcase_filter_levels)) {
4149
            if (!matchesAny(m_signature.m_name.c_str(), g_cs->filters[6], true, g_cs->case_sensitive))
4150
                return true;
4151
            if (matchesAny(m_signature.m_name.c_str(), g_cs->filters[7], false, g_cs->case_sensitive))
4152
                return true;
4153
        }
4154
        return false;
4155
    }
4156

4157
    Subcase::Subcase(const String& name, const char* file, int line)
4158
            : m_signature({name, file, line}) {
4159
        if (!g_cs->reachedLeaf) {
4160
            if (g_cs->nextSubcaseStack.size() <= g_cs->subcaseStack.size()
4161
                || g_cs->nextSubcaseStack[g_cs->subcaseStack.size()] == m_signature) {
4162
                // Going down.
4163
                if (checkFilters()) { return; }
4164

4165
                g_cs->subcaseStack.push_back(m_signature);
4166
                g_cs->currentSubcaseDepth++;
4167
                m_entered = true;
4168
                DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
4169
            }
4170
        } else {
4171
            if (g_cs->subcaseStack[g_cs->currentSubcaseDepth] == m_signature) {
4172
                // This subcase is reentered via control flow.
4173
                g_cs->currentSubcaseDepth++;
4174
                m_entered = true;
4175
                DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
4176
            } else if (g_cs->nextSubcaseStack.size() <= g_cs->currentSubcaseDepth
4177
                    && g_cs->fullyTraversedSubcases.find(hash(hash(g_cs->subcaseStack, g_cs->currentSubcaseDepth), hash(m_signature)))
4178
                    == g_cs->fullyTraversedSubcases.end()) {
4179
                if (checkFilters()) { return; }
4180
                // This subcase is part of the one to be executed next.
4181
                g_cs->nextSubcaseStack.clear();
4182
                g_cs->nextSubcaseStack.insert(g_cs->nextSubcaseStack.end(),
4183
                    g_cs->subcaseStack.begin(), g_cs->subcaseStack.begin() + g_cs->currentSubcaseDepth);
4184
                g_cs->nextSubcaseStack.push_back(m_signature);
4185
            }
4186
        }
4187
    }
4188

4189
    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
4190
    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
4191
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
4192

4193
    Subcase::~Subcase() {
4194
        if (m_entered) {
4195
            g_cs->currentSubcaseDepth--;
4196

4197
            if (!g_cs->reachedLeaf) {
4198
                // Leaf.
4199
                g_cs->fullyTraversedSubcases.insert(hash(g_cs->subcaseStack));
4200
                g_cs->nextSubcaseStack.clear();
4201
                g_cs->reachedLeaf = true;
4202
            } else if (g_cs->nextSubcaseStack.empty()) {
4203
                // All children are finished.
4204
                g_cs->fullyTraversedSubcases.insert(hash(g_cs->subcaseStack));
4205
            }
4206

4207
#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)
4208
            if(std::uncaught_exceptions() > 0
4209
#else
4210
            if(std::uncaught_exception()
4211
#endif
4212
                && g_cs->shouldLogCurrentException) {
4213
                DOCTEST_ITERATE_THROUGH_REPORTERS(
4214
                        test_case_exception, {"exception thrown in subcase - will translate later "
4215
                                                "when the whole test case has been exited (cannot "
4216
                                                "translate while there is an active exception)",
4217
                                                false});
4218
                g_cs->shouldLogCurrentException = false;
4219
            }
4220

4221
            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
4222
        }
4223
    }
4224

4225
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
4226
    DOCTEST_GCC_SUPPRESS_WARNING_POP
4227
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
4228

4229
    Subcase::operator bool() const { return m_entered; }
4230

4231
    Result::Result(bool passed, const String& decomposition)
4232
            : m_passed(passed)
4233
            , m_decomp(decomposition) {}
4234

4235
    ExpressionDecomposer::ExpressionDecomposer(assertType::Enum at)
4236
            : m_at(at) {}
4237

4238
    TestSuite& TestSuite::operator*(const char* in) {
4239
        m_test_suite = in;
4240
        return *this;
4241
    }
4242

4243
    TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
4244
                       const String& type, int template_id) {
4245
        m_file              = file;
4246
        m_line              = line;
4247
        m_name              = nullptr; // will be later overridden in operator*
4248
        m_test_suite        = test_suite.m_test_suite;
4249
        m_description       = test_suite.m_description;
4250
        m_skip              = test_suite.m_skip;
4251
        m_no_breaks         = test_suite.m_no_breaks;
4252
        m_no_output         = test_suite.m_no_output;
4253
        m_may_fail          = test_suite.m_may_fail;
4254
        m_should_fail       = test_suite.m_should_fail;
4255
        m_expected_failures = test_suite.m_expected_failures;
4256
        m_timeout           = test_suite.m_timeout;
4257

4258
        m_test        = test;
4259
        m_type        = type;
4260
        m_template_id = template_id;
4261
    }
4262

4263
    TestCase::TestCase(const TestCase& other)
4264
            : TestCaseData() {
4265
        *this = other;
4266
    }
4267

4268
    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(26434) // hides a non-virtual function
4269
    TestCase& TestCase::operator=(const TestCase& other) {
4270
        TestCaseData::operator=(other);
4271
        m_test        = other.m_test;
4272
        m_type        = other.m_type;
4273
        m_template_id = other.m_template_id;
4274
        m_full_name   = other.m_full_name;
4275

4276
        if(m_template_id != -1)
4277
            m_name = m_full_name.c_str();
4278
        return *this;
4279
    }
4280
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
4281

4282
    TestCase& TestCase::operator*(const char* in) {
4283
        m_name = in;
4284
        // make a new name with an appended type for templated test case
4285
        if(m_template_id != -1) {
4286
            m_full_name = String(m_name) + "<" + m_type + ">";
4287
            // redirect the name to point to the newly constructed full name
4288
            m_name = m_full_name.c_str();
4289
        }
4290
        return *this;
4291
    }
4292

4293
    bool TestCase::operator<(const TestCase& other) const {
4294
        // this will be used only to differentiate between test cases - not relevant for sorting
4295
        if(m_line != other.m_line)
4296
            return m_line < other.m_line;
4297
        const int name_cmp = strcmp(m_name, other.m_name);
4298
        if(name_cmp != 0)
4299
            return name_cmp < 0;
4300
        const int file_cmp = m_file.compare(other.m_file);
4301
        if(file_cmp != 0)
4302
            return file_cmp < 0;
4303
        return m_template_id < other.m_template_id;
4304
    }
4305

4306
    // all the registered tests
4307
    std::set<TestCase>& getRegisteredTests() {
4308
        static std::set<TestCase> data;
4309
        return data;
4310
    }
4311
} // namespace detail
4312
namespace {
4313
    using namespace detail;
4314
    // for sorting tests by file/line
4315
    bool fileOrderComparator(const TestCase* lhs, const TestCase* rhs) {
4316
        // this is needed because MSVC gives different case for drive letters
4317
        // for __FILE__ when evaluated in a header and a source file
4318
        const int res = lhs->m_file.compare(rhs->m_file, bool(DOCTEST_MSVC));
4319
        if(res != 0)
4320
            return res < 0;
4321
        if(lhs->m_line != rhs->m_line)
4322
            return lhs->m_line < rhs->m_line;
4323
        return lhs->m_template_id < rhs->m_template_id;
4324
    }
4325

4326
    // for sorting tests by suite/file/line
4327
    bool suiteOrderComparator(const TestCase* lhs, const TestCase* rhs) {
4328
        const int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite);
4329
        if(res != 0)
4330
            return res < 0;
4331
        return fileOrderComparator(lhs, rhs);
4332
    }
4333

4334
    // for sorting tests by name/suite/file/line
4335
    bool nameOrderComparator(const TestCase* lhs, const TestCase* rhs) {
4336
        const int res = std::strcmp(lhs->m_name, rhs->m_name);
4337
        if(res != 0)
4338
            return res < 0;
4339
        return suiteOrderComparator(lhs, rhs);
4340
    }
4341

4342
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
4343
    void color_to_stream(std::ostream& s, Color::Enum code) {
4344
        static_cast<void>(s);    // for DOCTEST_CONFIG_COLORS_NONE or DOCTEST_CONFIG_COLORS_WINDOWS
4345
        static_cast<void>(code); // for DOCTEST_CONFIG_COLORS_NONE
4346
#ifdef DOCTEST_CONFIG_COLORS_ANSI
4347
        if(g_no_colors ||
4348
           (isatty(STDOUT_FILENO) == false && getContextOptions()->force_colors == false))
4349
            return;
4350

4351
        auto col = "";
4352
        // clang-format off
4353
            switch(code) { //!OCLINT missing break in switch statement / unnecessary default statement in covered switch statement
4354
                case Color::Red:         col = "[0;31m"; break;
4355
                case Color::Green:       col = "[0;32m"; break;
4356
                case Color::Blue:        col = "[0;34m"; break;
4357
                case Color::Cyan:        col = "[0;36m"; break;
4358
                case Color::Yellow:      col = "[0;33m"; break;
4359
                case Color::Grey:        col = "[1;30m"; break;
4360
                case Color::LightGrey:   col = "[0;37m"; break;
4361
                case Color::BrightRed:   col = "[1;31m"; break;
4362
                case Color::BrightGreen: col = "[1;32m"; break;
4363
                case Color::BrightWhite: col = "[1;37m"; break;
4364
                case Color::Bright: // invalid
4365
                case Color::None:
4366
                case Color::White:
4367
                default:                 col = "[0m";
4368
            }
4369
        // clang-format on
4370
        s << "\033" << col;
4371
#endif // DOCTEST_CONFIG_COLORS_ANSI
4372

4373
#ifdef DOCTEST_CONFIG_COLORS_WINDOWS
4374
        if(g_no_colors ||
4375
           (_isatty(_fileno(stdout)) == false && getContextOptions()->force_colors == false))
4376
            return;
4377

4378
        static struct ConsoleHelper {
4379
            HANDLE stdoutHandle;
4380
            WORD   origFgAttrs;
4381
            WORD   origBgAttrs;
4382

4383
            ConsoleHelper() {
4384
                stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
4385
                CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
4386
                GetConsoleScreenBufferInfo(stdoutHandle, &csbiInfo);
4387
                origFgAttrs = csbiInfo.wAttributes & ~(BACKGROUND_GREEN | BACKGROUND_RED |
4388
                    BACKGROUND_BLUE | BACKGROUND_INTENSITY);
4389
                origBgAttrs = csbiInfo.wAttributes & ~(FOREGROUND_GREEN | FOREGROUND_RED |
4390
                    FOREGROUND_BLUE | FOREGROUND_INTENSITY);
4391
            }
4392
        } ch;
4393

4394
#define DOCTEST_SET_ATTR(x) SetConsoleTextAttribute(ch.stdoutHandle, x | ch.origBgAttrs)
4395

4396
        // clang-format off
4397
        switch (code) {
4398
            case Color::White:       DOCTEST_SET_ATTR(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
4399
            case Color::Red:         DOCTEST_SET_ATTR(FOREGROUND_RED);                                      break;
4400
            case Color::Green:       DOCTEST_SET_ATTR(FOREGROUND_GREEN);                                    break;
4401
            case Color::Blue:        DOCTEST_SET_ATTR(FOREGROUND_BLUE);                                     break;
4402
            case Color::Cyan:        DOCTEST_SET_ATTR(FOREGROUND_BLUE | FOREGROUND_GREEN);                  break;
4403
            case Color::Yellow:      DOCTEST_SET_ATTR(FOREGROUND_RED | FOREGROUND_GREEN);                   break;
4404
            case Color::Grey:        DOCTEST_SET_ATTR(0);                                                   break;
4405
            case Color::LightGrey:   DOCTEST_SET_ATTR(FOREGROUND_INTENSITY);                                break;
4406
            case Color::BrightRed:   DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_RED);               break;
4407
            case Color::BrightGreen: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN);             break;
4408
            case Color::BrightWhite: DOCTEST_SET_ATTR(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE); break;
4409
            case Color::None:
4410
            case Color::Bright: // invalid
4411
            default:                 DOCTEST_SET_ATTR(ch.origFgAttrs);
4412
        }
4413
            // clang-format on
4414
#endif // DOCTEST_CONFIG_COLORS_WINDOWS
4415
    }
4416
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
4417

4418
    std::vector<const IExceptionTranslator*>& getExceptionTranslators() {
4419
        static std::vector<const IExceptionTranslator*> data;
4420
        return data;
4421
    }
4422

4423
    String translateActiveException() {
4424
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
4425
        String res;
4426
        auto&  translators = getExceptionTranslators();
4427
        for(auto& curr : translators)
4428
            if(curr->translate(res))
4429
                return res;
4430
        // clang-format off
4431
        DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wcatch-value")
4432
        try {
4433
            throw;
4434
        } catch(std::exception& ex) {
4435
            return ex.what();
4436
        } catch(std::string& msg) {
4437
            return msg.c_str();
4438
        } catch(const char* msg) {
4439
            return msg;
4440
        } catch(...) {
4441
            return "unknown exception";
4442
        }
4443
        DOCTEST_GCC_SUPPRESS_WARNING_POP
4444
// clang-format on
4445
#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
4446
        return "";
4447
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
4448
    }
4449
} // namespace
4450

4451
namespace detail {
4452
    // used by the macros for registering tests
4453
    int regTest(const TestCase& tc) {
4454
        getRegisteredTests().insert(tc);
4455
        return 0;
4456
    }
4457

4458
    // sets the current test suite
4459
    int setTestSuite(const TestSuite& ts) {
4460
        doctest_detail_test_suite_ns::getCurrentTestSuite() = ts;
4461
        return 0;
4462
    }
4463

4464
#ifdef DOCTEST_IS_DEBUGGER_ACTIVE
4465
    bool isDebuggerActive() { return DOCTEST_IS_DEBUGGER_ACTIVE(); }
4466
#else // DOCTEST_IS_DEBUGGER_ACTIVE
4467
#ifdef DOCTEST_PLATFORM_LINUX
4468
    class ErrnoGuard {
4469
    public:
4470
        ErrnoGuard() : m_oldErrno(errno) {}
4471
        ~ErrnoGuard() { errno = m_oldErrno; }
4472
    private:
4473
        int m_oldErrno;
4474
    };
4475
    // See the comments in Catch2 for the reasoning behind this implementation:
4476
    // https://github.com/catchorg/Catch2/blob/v2.13.1/include/internal/catch_debugger.cpp#L79-L102
4477
    bool isDebuggerActive() {
4478
        ErrnoGuard guard;
4479
        std::ifstream in("/proc/self/status");
4480
        for(std::string line; std::getline(in, line);) {
4481
            static const int PREFIX_LEN = 11;
4482
            if(line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0) {
4483
                return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
4484
            }
4485
        }
4486
        return false;
4487
    }
4488
#elif defined(DOCTEST_PLATFORM_MAC)
4489
    // The following function is taken directly from the following technical note:
4490
    // https://developer.apple.com/library/archive/qa/qa1361/_index.html
4491
    // Returns true if the current process is being debugged (either
4492
    // running under the debugger or has a debugger attached post facto).
4493
    bool isDebuggerActive() {
4494
        int        mib[4];
4495
        kinfo_proc info;
4496
        size_t     size;
4497
        // Initialize the flags so that, if sysctl fails for some bizarre
4498
        // reason, we get a predictable result.
4499
        info.kp_proc.p_flag = 0;
4500
        // Initialize mib, which tells sysctl the info we want, in this case
4501
        // we're looking for information about a specific process ID.
4502
        mib[0] = CTL_KERN;
4503
        mib[1] = KERN_PROC;
4504
        mib[2] = KERN_PROC_PID;
4505
        mib[3] = getpid();
4506
        // Call sysctl.
4507
        size = sizeof(info);
4508
        if(sysctl(mib, DOCTEST_COUNTOF(mib), &info, &size, 0, 0) != 0) {
4509
            std::cerr << "\nCall to sysctl failed - unable to determine if debugger is active **\n";
4510
            return false;
4511
        }
4512
        // We're being debugged if the P_TRACED flag is set.
4513
        return ((info.kp_proc.p_flag & P_TRACED) != 0);
4514
    }
4515
#elif DOCTEST_MSVC || defined(__MINGW32__) || defined(__MINGW64__)
4516
    bool isDebuggerActive() { return ::IsDebuggerPresent() != 0; }
4517
#else
4518
    bool isDebuggerActive() { return false; }
4519
#endif // Platform
4520
#endif // DOCTEST_IS_DEBUGGER_ACTIVE
4521

4522
    void registerExceptionTranslatorImpl(const IExceptionTranslator* et) {
4523
        if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) ==
4524
           getExceptionTranslators().end())
4525
            getExceptionTranslators().push_back(et);
4526
    }
4527

4528
    DOCTEST_THREAD_LOCAL std::vector<IContextScope*> g_infoContexts; // for logging with INFO()
4529

4530
    ContextScopeBase::ContextScopeBase() {
4531
        g_infoContexts.push_back(this);
4532
    }
4533

4534
    ContextScopeBase::ContextScopeBase(ContextScopeBase&& other) noexcept {
4535
        if (other.need_to_destroy) {
4536
            other.destroy();
4537
        }
4538
        other.need_to_destroy = false;
4539
        g_infoContexts.push_back(this);
4540
    }
4541

4542
    DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4996) // std::uncaught_exception is deprecated in C++17
4543
    DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
4544
    DOCTEST_CLANG_SUPPRESS_WARNING_WITH_PUSH("-Wdeprecated-declarations")
4545

4546
    // destroy cannot be inlined into the destructor because that would mean calling stringify after
4547
    // ContextScope has been destroyed (base class destructors run after derived class destructors).
4548
    // Instead, ContextScope calls this method directly from its destructor.
4549
    void ContextScopeBase::destroy() {
4550
#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)
4551
        if(std::uncaught_exceptions() > 0) {
4552
#else
4553
        if(std::uncaught_exception()) {
4554
#endif
4555
            std::ostringstream s;
4556
            this->stringify(&s);
4557
            g_cs->stringifiedContexts.push_back(s.str().c_str());
4558
        }
4559
        g_infoContexts.pop_back();
4560
    }
4561

4562
    DOCTEST_CLANG_SUPPRESS_WARNING_POP
4563
    DOCTEST_GCC_SUPPRESS_WARNING_POP
4564
    DOCTEST_MSVC_SUPPRESS_WARNING_POP
4565
} // namespace detail
4566
namespace {
4567
    using namespace detail;
4568

4569
#if !defined(DOCTEST_CONFIG_POSIX_SIGNALS) && !defined(DOCTEST_CONFIG_WINDOWS_SEH)
4570
    struct FatalConditionHandler
4571
    {
4572
        static void reset() {}
4573
        static void allocateAltStackMem() {}
4574
        static void freeAltStackMem() {}
4575
    };
4576
#else // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
4577

4578
    void reportFatal(const std::string&);
4579

4580
#ifdef DOCTEST_PLATFORM_WINDOWS
4581

4582
    struct SignalDefs
4583
    {
4584
        DWORD id;
4585
        const char* name;
4586
    };
4587
    // There is no 1-1 mapping between signals and windows exceptions.
4588
    // Windows can easily distinguish between SO and SigSegV,
4589
    // but SigInt, SigTerm, etc are handled differently.
4590
    SignalDefs signalDefs[] = {
4591
            {static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),
4592
             "SIGILL - Illegal instruction signal"},
4593
            {static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow"},
4594
            {static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION),
4595
             "SIGSEGV - Segmentation violation signal"},
4596
            {static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error"},
4597
    };
4598

4599
    struct FatalConditionHandler
4600
    {
4601
        static LONG CALLBACK handleException(PEXCEPTION_POINTERS ExceptionInfo) {
4602
            // Multiple threads may enter this filter/handler at once. We want the error message to be printed on the
4603
            // console just once no matter how many threads have crashed.
4604
            DOCTEST_DECLARE_STATIC_MUTEX(mutex)
4605
            static bool execute = true;
4606
            {
4607
                DOCTEST_LOCK_MUTEX(mutex)
4608
                if(execute) {
4609
                    bool reported = false;
4610
                    for(size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
4611
                        if(ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
4612
                            reportFatal(signalDefs[i].name);
4613
                            reported = true;
4614
                            break;
4615
                        }
4616
                    }
4617
                    if(reported == false)
4618
                        reportFatal("Unhandled SEH exception caught");
4619
                    if(isDebuggerActive() && !g_cs->no_breaks)
4620
                        DOCTEST_BREAK_INTO_DEBUGGER();
4621
                }
4622
                execute = false;
4623
            }
4624
            std::exit(EXIT_FAILURE);
4625
        }
4626

4627
        static void allocateAltStackMem() {}
4628
        static void freeAltStackMem() {}
4629

4630
        FatalConditionHandler() {
4631
            isSet = true;
4632
            // 32k seems enough for doctest to handle stack overflow,
4633
            // but the value was found experimentally, so there is no strong guarantee
4634
            guaranteeSize = 32 * 1024;
4635
            // Register an unhandled exception filter
4636
            previousTop = SetUnhandledExceptionFilter(handleException);
4637
            // Pass in guarantee size to be filled
4638
            SetThreadStackGuarantee(&guaranteeSize);
4639

4640
            // On Windows uncaught exceptions from another thread, exceptions from
4641
            // destructors, or calls to std::terminate are not a SEH exception
4642

4643
            // The terminal handler gets called when:
4644
            // - std::terminate is called FROM THE TEST RUNNER THREAD
4645
            // - an exception is thrown from a destructor FROM THE TEST RUNNER THREAD
4646
            original_terminate_handler = std::get_terminate();
4647
            std::set_terminate([]() DOCTEST_NOEXCEPT {
4648
                reportFatal("Terminate handler called");
4649
                if(isDebuggerActive() && !g_cs->no_breaks)
4650
                    DOCTEST_BREAK_INTO_DEBUGGER();
4651
                std::exit(EXIT_FAILURE); // explicitly exit - otherwise the SIGABRT handler may be called as well
4652
            });
4653

4654
            // SIGABRT is raised when:
4655
            // - std::terminate is called FROM A DIFFERENT THREAD
4656
            // - an exception is thrown from a destructor FROM A DIFFERENT THREAD
4657
            // - an uncaught exception is thrown FROM A DIFFERENT THREAD
4658
            prev_sigabrt_handler = std::signal(SIGABRT, [](int signal) DOCTEST_NOEXCEPT {
4659
                if(signal == SIGABRT) {
4660
                    reportFatal("SIGABRT - Abort (abnormal termination) signal");
4661
                    if(isDebuggerActive() && !g_cs->no_breaks)
4662
                        DOCTEST_BREAK_INTO_DEBUGGER();
4663
                    std::exit(EXIT_FAILURE);
4664
                }
4665
            });
4666

4667
            // The following settings are taken from google test, and more
4668
            // specifically from UnitTest::Run() inside of gtest.cc
4669

4670
            // the user does not want to see pop-up dialogs about crashes
4671
            prev_error_mode_1 = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
4672
                                             SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
4673
            // This forces the abort message to go to stderr in all circumstances.
4674
            prev_error_mode_2 = _set_error_mode(_OUT_TO_STDERR);
4675
            // In the debug version, Visual Studio pops up a separate dialog
4676
            // offering a choice to debug the aborted program - we want to disable that.
4677
            prev_abort_behavior = _set_abort_behavior(0x0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
4678
            // In debug mode, the Windows CRT can crash with an assertion over invalid
4679
            // input (e.g. passing an invalid file descriptor). The default handling
4680
            // for these assertions is to pop up a dialog and wait for user input.
4681
            // Instead ask the CRT to dump such assertions to stderr non-interactively.
4682
            prev_report_mode = _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
4683
            prev_report_file = _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
4684
        }
4685

4686
        static void reset() {
4687
            if(isSet) {
4688
                // Unregister handler and restore the old guarantee
4689
                SetUnhandledExceptionFilter(previousTop);
4690
                SetThreadStackGuarantee(&guaranteeSize);
4691
                std::set_terminate(original_terminate_handler);
4692
                std::signal(SIGABRT, prev_sigabrt_handler);
4693
                SetErrorMode(prev_error_mode_1);
4694
                _set_error_mode(prev_error_mode_2);
4695
                _set_abort_behavior(prev_abort_behavior, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
4696
                static_cast<void>(_CrtSetReportMode(_CRT_ASSERT, prev_report_mode));
4697
                static_cast<void>(_CrtSetReportFile(_CRT_ASSERT, prev_report_file));
4698
                isSet = false;
4699
            }
4700
        }
4701

4702
        ~FatalConditionHandler() { reset(); }
4703

4704
    private:
4705
        static UINT         prev_error_mode_1;
4706
        static int          prev_error_mode_2;
4707
        static unsigned int prev_abort_behavior;
4708
        static int          prev_report_mode;
4709
        static _HFILE       prev_report_file;
4710
        static void (DOCTEST_CDECL *prev_sigabrt_handler)(int);
4711
        static std::terminate_handler original_terminate_handler;
4712
        static bool isSet;
4713
        static ULONG guaranteeSize;
4714
        static LPTOP_LEVEL_EXCEPTION_FILTER previousTop;
4715
    };
4716

4717
    UINT         FatalConditionHandler::prev_error_mode_1;
4718
    int          FatalConditionHandler::prev_error_mode_2;
4719
    unsigned int FatalConditionHandler::prev_abort_behavior;
4720
    int          FatalConditionHandler::prev_report_mode;
4721
    _HFILE       FatalConditionHandler::prev_report_file;
4722
    void (DOCTEST_CDECL *FatalConditionHandler::prev_sigabrt_handler)(int);
4723
    std::terminate_handler FatalConditionHandler::original_terminate_handler;
4724
    bool FatalConditionHandler::isSet = false;
4725
    ULONG FatalConditionHandler::guaranteeSize = 0;
4726
    LPTOP_LEVEL_EXCEPTION_FILTER FatalConditionHandler::previousTop = nullptr;
4727

4728
#else // DOCTEST_PLATFORM_WINDOWS
4729

4730
    struct SignalDefs
4731
    {
4732
        int         id;
4733
        const char* name;
4734
    };
4735
    SignalDefs signalDefs[] = {{SIGINT, "SIGINT - Terminal interrupt signal"},
4736
                               {SIGILL, "SIGILL - Illegal instruction signal"},
4737
                               {SIGFPE, "SIGFPE - Floating point error signal"},
4738
                               {SIGSEGV, "SIGSEGV - Segmentation violation signal"},
4739
                               {SIGTERM, "SIGTERM - Termination request signal"},
4740
                               {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}};
4741

4742
    struct FatalConditionHandler
4743
    {
4744
        static bool             isSet;
4745
        static struct sigaction oldSigActions[DOCTEST_COUNTOF(signalDefs)];
4746
        static stack_t          oldSigStack;
4747
        static size_t           altStackSize;
4748
        static char*            altStackMem;
4749

4750
        static void handleSignal(int sig) {
4751
            const char* name = "<unknown signal>";
4752
            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
4753
                SignalDefs& def = signalDefs[i];
4754
                if(sig == def.id) {
4755
                    name = def.name;
4756
                    break;
4757
                }
4758
            }
4759
            reset();
4760
            reportFatal(name);
4761
            raise(sig);
4762
        }
4763

4764
        static void allocateAltStackMem() {
4765
            altStackMem = new char[altStackSize];
4766
        }
4767

4768
        static void freeAltStackMem() {
4769
            delete[] altStackMem;
4770
        }
4771

4772
        FatalConditionHandler() {
4773
            isSet = true;
4774
            stack_t sigStack;
4775
            sigStack.ss_sp    = altStackMem;
4776
            sigStack.ss_size  = altStackSize;
4777
            sigStack.ss_flags = 0;
4778
            sigaltstack(&sigStack, &oldSigStack);
4779
            struct sigaction sa = {};
4780
            sa.sa_handler       = handleSignal;
4781
            sa.sa_flags         = SA_ONSTACK;
4782
            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
4783
                sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
4784
            }
4785
        }
4786

4787
        ~FatalConditionHandler() { reset(); }
4788
        static void reset() {
4789
            if(isSet) {
4790
                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
4791
                for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
4792
                    sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
4793
                }
4794
                // Return the old stack
4795
                sigaltstack(&oldSigStack, nullptr);
4796
                isSet = false;
4797
            }
4798
        }
4799
    };
4800

4801
    bool             FatalConditionHandler::isSet = false;
4802
    struct sigaction FatalConditionHandler::oldSigActions[DOCTEST_COUNTOF(signalDefs)] = {};
4803
    stack_t          FatalConditionHandler::oldSigStack = {};
4804
    size_t           FatalConditionHandler::altStackSize = 4 * SIGSTKSZ;
4805
    char*            FatalConditionHandler::altStackMem = nullptr;
4806

4807
#endif // DOCTEST_PLATFORM_WINDOWS
4808
#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
4809

4810
} // namespace
4811

4812
namespace {
4813
    using namespace detail;
4814

4815
#ifdef DOCTEST_PLATFORM_WINDOWS
4816
#define DOCTEST_OUTPUT_DEBUG_STRING(text) ::OutputDebugStringA(text)
4817
#else
4818
    // TODO: integration with XCode and other IDEs
4819
#define DOCTEST_OUTPUT_DEBUG_STRING(text)
4820
#endif // Platform
4821

4822
    void addAssert(assertType::Enum at) {
4823
        if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
4824
            g_cs->numAssertsCurrentTest_atomic++;
4825
    }
4826

4827
    void addFailedAssert(assertType::Enum at) {
4828
        if((at & assertType::is_warn) == 0) //!OCLINT bitwise operator in conditional
4829
            g_cs->numAssertsFailedCurrentTest_atomic++;
4830
    }
4831

4832
#if defined(DOCTEST_CONFIG_POSIX_SIGNALS) || defined(DOCTEST_CONFIG_WINDOWS_SEH)
4833
    void reportFatal(const std::string& message) {
4834
        g_cs->failure_flags |= TestCaseFailureReason::Crash;
4835

4836
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception, {message.c_str(), true});
4837

4838
        while (g_cs->subcaseStack.size()) {
4839
            g_cs->subcaseStack.pop_back();
4840
            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
4841
        }
4842

4843
        g_cs->finalizeTestCaseData();
4844

4845
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);
4846

4847
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
4848
    }
4849
#endif // DOCTEST_CONFIG_POSIX_SIGNALS || DOCTEST_CONFIG_WINDOWS_SEH
4850
} // namespace
4851

4852
AssertData::AssertData(assertType::Enum at, const char* file, int line, const char* expr,
4853
    const char* exception_type, const StringContains& exception_string)
4854
    : m_test_case(g_cs->currentTest), m_at(at), m_file(file), m_line(line), m_expr(expr),
4855
    m_failed(true), m_threw(false), m_threw_as(false), m_exception_type(exception_type),
4856
    m_exception_string(exception_string) {
4857
#if DOCTEST_MSVC
4858
    if (m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC
4859
        ++m_expr;
4860
#endif // MSVC
4861
}
4862

4863
namespace detail {
4864
    ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
4865
                                 const char* exception_type, const String& exception_string)
4866
        : AssertData(at, file, line, expr, exception_type, exception_string) { }
4867

4868
    ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
4869
        const char* exception_type, const Contains& exception_string)
4870
        : AssertData(at, file, line, expr, exception_type, exception_string) { }
4871

4872
    void ResultBuilder::setResult(const Result& res) {
4873
        m_decomp = res.m_decomp;
4874
        m_failed = !res.m_passed;
4875
    }
4876

4877
    void ResultBuilder::translateException() {
4878
        m_threw     = true;
4879
        m_exception = translateActiveException();
4880
    }
4881

4882
    bool ResultBuilder::log() {
4883
        if(m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
4884
            m_failed = !m_threw;
4885
        } else if((m_at & assertType::is_throws_as) && (m_at & assertType::is_throws_with)) { //!OCLINT
4886
            m_failed = !m_threw_as || !m_exception_string.check(m_exception);
4887
        } else if(m_at & assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
4888
            m_failed = !m_threw_as;
4889
        } else if(m_at & assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
4890
            m_failed = !m_exception_string.check(m_exception);
4891
        } else if(m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
4892
            m_failed = m_threw;
4893
        }
4894

4895
        if(m_exception.size())
4896
            m_exception = "\"" + m_exception + "\"";
4897

4898
        if(is_running_in_test) {
4899
            addAssert(m_at);
4900
            DOCTEST_ITERATE_THROUGH_REPORTERS(log_assert, *this);
4901

4902
            if(m_failed)
4903
                addFailedAssert(m_at);
4904
        } else if(m_failed) {
4905
            failed_out_of_a_testing_context(*this);
4906
        }
4907

4908
        return m_failed && isDebuggerActive() && !getContextOptions()->no_breaks &&
4909
            (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
4910
    }
4911

4912
    void ResultBuilder::react() const {
4913
        if(m_failed && checkIfShouldThrow(m_at))
4914
            throwException();
4915
    }
4916

4917
    void failed_out_of_a_testing_context(const AssertData& ad) {
4918
        if(g_cs->ah)
4919
            g_cs->ah(ad);
4920
        else
4921
            std::abort();
4922
    }
4923

4924
    bool decomp_assert(assertType::Enum at, const char* file, int line, const char* expr,
4925
                       const Result& result) {
4926
        bool failed = !result.m_passed;
4927

4928
        // ###################################################################################
4929
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
4930
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
4931
        // ###################################################################################
4932
        DOCTEST_ASSERT_OUT_OF_TESTS(result.m_decomp);
4933
        DOCTEST_ASSERT_IN_TESTS(result.m_decomp);
4934
        return !failed;
4935
    }
4936

4937
    MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
4938
        m_stream   = tlssPush();
4939
        m_file     = file;
4940
        m_line     = line;
4941
        m_severity = severity;
4942
    }
4943

4944
    MessageBuilder::~MessageBuilder() {
4945
        if (!logged)
4946
            tlssPop();
4947
    }
4948

4949
    DOCTEST_DEFINE_INTERFACE(IExceptionTranslator)
4950

4951
    bool MessageBuilder::log() {
4952
        if (!logged) {
4953
            m_string = tlssPop();
4954
            logged = true;
4955
        }
4956

4957
        DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
4958

4959
        const bool isWarn = m_severity & assertType::is_warn;
4960

4961
        // warn is just a message in this context so we don't treat it as an assert
4962
        if(!isWarn) {
4963
            addAssert(m_severity);
4964
            addFailedAssert(m_severity);
4965
        }
4966

4967
        return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn &&
4968
            (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
4969
    }
4970

4971
    void MessageBuilder::react() {
4972
        if(m_severity & assertType::is_require) //!OCLINT bitwise operator in conditional
4973
            throwException();
4974
    }
4975
} // namespace detail
4976
namespace {
4977
    using namespace detail;
4978

4979
    // clang-format off
4980

4981
// =================================================================================================
4982
// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
4983
// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
4984
// =================================================================================================
4985

4986
    class XmlEncode {
4987
    public:
4988
        enum ForWhat { ForTextNodes, ForAttributes };
4989

4990
        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
4991

4992
        void encodeTo( std::ostream& os ) const;
4993

4994
        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
4995

4996
    private:
4997
        std::string m_str;
4998
        ForWhat m_forWhat;
4999
    };
5000

5001
    class XmlWriter {
5002
    public:
5003

5004
        class ScopedElement {
5005
        public:
5006
            ScopedElement( XmlWriter* writer );
5007

5008
            ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT;
5009
            ScopedElement& operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT;
5010

5011
            ~ScopedElement();
5012

5013
            ScopedElement& writeText( std::string const& text, bool indent = true );
5014

5015
            template<typename T>
5016
            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
5017
                m_writer->writeAttribute( name, attribute );
5018
                return *this;
5019
            }
5020

5021
        private:
5022
            mutable XmlWriter* m_writer = nullptr;
5023
        };
5024

5025
        XmlWriter( std::ostream& os = std::cout );
5026
        ~XmlWriter();
5027

5028
        XmlWriter( XmlWriter const& ) = delete;
5029
        XmlWriter& operator=( XmlWriter const& ) = delete;
5030

5031
        XmlWriter& startElement( std::string const& name );
5032

5033
        ScopedElement scopedElement( std::string const& name );
5034

5035
        XmlWriter& endElement();
5036

5037
        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
5038

5039
        XmlWriter& writeAttribute( std::string const& name, const char* attribute );
5040

5041
        XmlWriter& writeAttribute( std::string const& name, bool attribute );
5042

5043
        template<typename T>
5044
        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
5045
        std::stringstream rss;
5046
            rss << attribute;
5047
            return writeAttribute( name, rss.str() );
5048
        }
5049

5050
        XmlWriter& writeText( std::string const& text, bool indent = true );
5051

5052
        //XmlWriter& writeComment( std::string const& text );
5053

5054
        //void writeStylesheetRef( std::string const& url );
5055

5056
        //XmlWriter& writeBlankLine();
5057

5058
        void ensureTagClosed();
5059

5060
        void writeDeclaration();
5061

5062
    private:
5063

5064
        void newlineIfNecessary();
5065

5066
        bool m_tagIsOpen = false;
5067
        bool m_needsNewline = false;
5068
        std::vector<std::string> m_tags;
5069
        std::string m_indent;
5070
        std::ostream& m_os;
5071
    };
5072

5073
// =================================================================================================
5074
// The following code has been taken verbatim from Catch2/include/internal/catch_xmlwriter.h/cpp
5075
// This is done so cherry-picking bug fixes is trivial - even the style/formatting is untouched.
5076
// =================================================================================================
5077

5078
using uchar = unsigned char;
5079

5080
namespace {
5081

5082
    size_t trailingBytes(unsigned char c) {
5083
        if ((c & 0xE0) == 0xC0) {
5084
            return 2;
5085
        }
5086
        if ((c & 0xF0) == 0xE0) {
5087
            return 3;
5088
        }
5089
        if ((c & 0xF8) == 0xF0) {
5090
            return 4;
5091
        }
5092
        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
5093
    }
5094

5095
    uint32_t headerValue(unsigned char c) {
5096
        if ((c & 0xE0) == 0xC0) {
5097
            return c & 0x1F;
5098
        }
5099
        if ((c & 0xF0) == 0xE0) {
5100
            return c & 0x0F;
5101
        }
5102
        if ((c & 0xF8) == 0xF0) {
5103
            return c & 0x07;
5104
        }
5105
        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
5106
    }
5107

5108
    void hexEscapeChar(std::ostream& os, unsigned char c) {
5109
        std::ios_base::fmtflags f(os.flags());
5110
        os << "\\x"
5111
            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
5112
            << static_cast<int>(c);
5113
        os.flags(f);
5114
    }
5115

5116
} // anonymous namespace
5117

5118
    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
5119
    :   m_str( str ),
5120
        m_forWhat( forWhat )
5121
    {}
5122

5123
    void XmlEncode::encodeTo( std::ostream& os ) const {
5124
        // Apostrophe escaping not necessary if we always use " to write attributes
5125
        // (see: https://www.w3.org/TR/xml/#syntax)
5126

5127
        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
5128
            uchar c = m_str[idx];
5129
            switch (c) {
5130
            case '<':   os << "&lt;"; break;
5131
            case '&':   os << "&amp;"; break;
5132

5133
            case '>':
5134
                // See: https://www.w3.org/TR/xml/#syntax
5135
                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
5136
                    os << "&gt;";
5137
                else
5138
                    os << c;
5139
                break;
5140

5141
            case '\"':
5142
                if (m_forWhat == ForAttributes)
5143
                    os << "&quot;";
5144
                else
5145
                    os << c;
5146
                break;
5147

5148
            default:
5149
                // Check for control characters and invalid utf-8
5150

5151
                // Escape control characters in standard ascii
5152
                // see https://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
5153
                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
5154
                    hexEscapeChar(os, c);
5155
                    break;
5156
                }
5157

5158
                // Plain ASCII: Write it to stream
5159
                if (c < 0x7F) {
5160
                    os << c;
5161
                    break;
5162
                }
5163

5164
                // UTF-8 territory
5165
                // Check if the encoding is valid and if it is not, hex escape bytes.
5166
                // Important: We do not check the exact decoded values for validity, only the encoding format
5167
                // First check that this bytes is a valid lead byte:
5168
                // This means that it is not encoded as 1111 1XXX
5169
                // Or as 10XX XXXX
5170
                if (c <  0xC0 ||
5171
                    c >= 0xF8) {
5172
                    hexEscapeChar(os, c);
5173
                    break;
5174
                }
5175

5176
                auto encBytes = trailingBytes(c);
5177
                // Are there enough bytes left to avoid accessing out-of-bounds memory?
5178
                if (idx + encBytes - 1 >= m_str.size()) {
5179
                    hexEscapeChar(os, c);
5180
                    break;
5181
                }
5182
                // The header is valid, check data
5183
                // The next encBytes bytes must together be a valid utf-8
5184
                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
5185
                bool valid = true;
5186
                uint32_t value = headerValue(c);
5187
                for (std::size_t n = 1; n < encBytes; ++n) {
5188
                    uchar nc = m_str[idx + n];
5189
                    valid &= ((nc & 0xC0) == 0x80);
5190
                    value = (value << 6) | (nc & 0x3F);
5191
                }
5192

5193
                if (
5194
                    // Wrong bit pattern of following bytes
5195
                    (!valid) ||
5196
                    // Overlong encodings
5197
                    (value < 0x80) ||
5198
                    (                 value < 0x800   && encBytes > 2) || // removed "0x80 <= value &&" because redundant
5199
                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
5200
                    // Encoded value out of range
5201
                    (value >= 0x110000)
5202
                    ) {
5203
                    hexEscapeChar(os, c);
5204
                    break;
5205
                }
5206

5207
                // If we got here, this is in fact a valid(ish) utf-8 sequence
5208
                for (std::size_t n = 0; n < encBytes; ++n) {
5209
                    os << m_str[idx + n];
5210
                }
5211
                idx += encBytes - 1;
5212
                break;
5213
            }
5214
        }
5215
    }
5216

5217
    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
5218
        xmlEncode.encodeTo( os );
5219
        return os;
5220
    }
5221

5222
    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
5223
    :   m_writer( writer )
5224
    {}
5225

5226
    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) DOCTEST_NOEXCEPT
5227
    :   m_writer( other.m_writer ){
5228
        other.m_writer = nullptr;
5229
    }
5230
    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) DOCTEST_NOEXCEPT {
5231
        if ( m_writer ) {
5232
            m_writer->endElement();
5233
        }
5234
        m_writer = other.m_writer;
5235
        other.m_writer = nullptr;
5236
        return *this;
5237
    }
5238

5239

5240
    XmlWriter::ScopedElement::~ScopedElement() {
5241
        if( m_writer )
5242
            m_writer->endElement();
5243
    }
5244

5245
    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
5246
        m_writer->writeText( text, indent );
5247
        return *this;
5248
    }
5249

5250
    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
5251
    {
5252
        // writeDeclaration(); // called explicitly by the reporters that use the writer class - see issue #627
5253
    }
5254

5255
    XmlWriter::~XmlWriter() {
5256
        while( !m_tags.empty() )
5257
            endElement();
5258
    }
5259

5260
    XmlWriter& XmlWriter::startElement( std::string const& name ) {
5261
        ensureTagClosed();
5262
        newlineIfNecessary();
5263
        m_os << m_indent << '<' << name;
5264
        m_tags.push_back( name );
5265
        m_indent += "  ";
5266
        m_tagIsOpen = true;
5267
        return *this;
5268
    }
5269

5270
    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
5271
        ScopedElement scoped( this );
5272
        startElement( name );
5273
        return scoped;
5274
    }
5275

5276
    XmlWriter& XmlWriter::endElement() {
5277
        newlineIfNecessary();
5278
        m_indent = m_indent.substr( 0, m_indent.size()-2 );
5279
        if( m_tagIsOpen ) {
5280
            m_os << "/>";
5281
            m_tagIsOpen = false;
5282
        }
5283
        else {
5284
            m_os << m_indent << "</" << m_tags.back() << ">";
5285
        }
5286
        m_os << std::endl;
5287
        m_tags.pop_back();
5288
        return *this;
5289
    }
5290

5291
    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
5292
        if( !name.empty() && !attribute.empty() )
5293
            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
5294
        return *this;
5295
    }
5296

5297
    XmlWriter& XmlWriter::writeAttribute( std::string const& name, const char* attribute ) {
5298
        if( !name.empty() && attribute && attribute[0] != '\0' )
5299
            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
5300
        return *this;
5301
    }
5302

5303
    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
5304
        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
5305
        return *this;
5306
    }
5307

5308
    XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
5309
        if( !text.empty() ){
5310
            bool tagWasOpen = m_tagIsOpen;
5311
            ensureTagClosed();
5312
            if( tagWasOpen && indent )
5313
                m_os << m_indent;
5314
            m_os << XmlEncode( text );
5315
            m_needsNewline = true;
5316
        }
5317
        return *this;
5318
    }
5319

5320
    //XmlWriter& XmlWriter::writeComment( std::string const& text ) {
5321
    //    ensureTagClosed();
5322
    //    m_os << m_indent << "<!--" << text << "-->";
5323
    //    m_needsNewline = true;
5324
    //    return *this;
5325
    //}
5326

5327
    //void XmlWriter::writeStylesheetRef( std::string const& url ) {
5328
    //    m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
5329
    //}
5330

5331
    //XmlWriter& XmlWriter::writeBlankLine() {
5332
    //    ensureTagClosed();
5333
    //    m_os << '\n';
5334
    //    return *this;
5335
    //}
5336

5337
    void XmlWriter::ensureTagClosed() {
5338
        if( m_tagIsOpen ) {
5339
            m_os << ">" << std::endl;
5340
            m_tagIsOpen = false;
5341
        }
5342
    }
5343

5344
    void XmlWriter::writeDeclaration() {
5345
        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
5346
    }
5347

5348
    void XmlWriter::newlineIfNecessary() {
5349
        if( m_needsNewline ) {
5350
            m_os << std::endl;
5351
            m_needsNewline = false;
5352
        }
5353
    }
5354

5355
// =================================================================================================
5356
// End of copy-pasted code from Catch
5357
// =================================================================================================
5358

5359
    // clang-format on
5360

5361
    struct XmlReporter : public IReporter
5362
    {
5363
        XmlWriter xml;
5364
        DOCTEST_DECLARE_MUTEX(mutex)
5365

5366
        // caching pointers/references to objects of these types - safe to do
5367
        const ContextOptions& opt;
5368
        const TestCaseData*   tc = nullptr;
5369

5370
        XmlReporter(const ContextOptions& co)
5371
                : xml(*co.cout)
5372
                , opt(co) {}
5373

5374
        void log_contexts() {
5375
            int num_contexts = get_num_active_contexts();
5376
            if(num_contexts) {
5377
                auto              contexts = get_active_contexts();
5378
                std::stringstream ss;
5379
                for(int i = 0; i < num_contexts; ++i) {
5380
                    contexts[i]->stringify(&ss);
5381
                    xml.scopedElement("Info").writeText(ss.str());
5382
                    ss.str("");
5383
                }
5384
            }
5385
        }
5386

5387
        unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; }
5388

5389
        void test_case_start_impl(const TestCaseData& in) {
5390
            bool open_ts_tag = false;
5391
            if(tc != nullptr) { // we have already opened a test suite
5392
                if(std::strcmp(tc->m_test_suite, in.m_test_suite) != 0) {
5393
                    xml.endElement();
5394
                    open_ts_tag = true;
5395
                }
5396
            }
5397
            else {
5398
                open_ts_tag = true; // first test case ==> first test suite
5399
            }
5400

5401
            if(open_ts_tag) {
5402
                xml.startElement("TestSuite");
5403
                xml.writeAttribute("name", in.m_test_suite);
5404
            }
5405

5406
            tc = &in;
5407
            xml.startElement("TestCase")
5408
                    .writeAttribute("name", in.m_name)
5409
                    .writeAttribute("filename", skipPathFromFilename(in.m_file.c_str()))
5410
                    .writeAttribute("line", line(in.m_line))
5411
                    .writeAttribute("description", in.m_description);
5412

5413
            if(Approx(in.m_timeout) != 0)
5414
                xml.writeAttribute("timeout", in.m_timeout);
5415
            if(in.m_may_fail)
5416
                xml.writeAttribute("may_fail", true);
5417
            if(in.m_should_fail)
5418
                xml.writeAttribute("should_fail", true);
5419
        }
5420

5421
        // =========================================================================================
5422
        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
5423
        // =========================================================================================
5424

5425
        void report_query(const QueryData& in) override {
5426
            test_run_start();
5427
            if(opt.list_reporters) {
5428
                for(auto& curr : getListeners())
5429
                    xml.scopedElement("Listener")
5430
                            .writeAttribute("priority", curr.first.first)
5431
                            .writeAttribute("name", curr.first.second);
5432
                for(auto& curr : getReporters())
5433
                    xml.scopedElement("Reporter")
5434
                            .writeAttribute("priority", curr.first.first)
5435
                            .writeAttribute("name", curr.first.second);
5436
            } else if(opt.count || opt.list_test_cases) {
5437
                for(unsigned i = 0; i < in.num_data; ++i) {
5438
                    xml.scopedElement("TestCase").writeAttribute("name", in.data[i]->m_name)
5439
                        .writeAttribute("testsuite", in.data[i]->m_test_suite)
5440
                        .writeAttribute("filename", skipPathFromFilename(in.data[i]->m_file.c_str()))
5441
                        .writeAttribute("line", line(in.data[i]->m_line))
5442
                        .writeAttribute("skipped", in.data[i]->m_skip);
5443
                }
5444
                xml.scopedElement("OverallResultsTestCases")
5445
                        .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
5446
            } else if(opt.list_test_suites) {
5447
                for(unsigned i = 0; i < in.num_data; ++i)
5448
                    xml.scopedElement("TestSuite").writeAttribute("name", in.data[i]->m_test_suite);
5449
                xml.scopedElement("OverallResultsTestCases")
5450
                        .writeAttribute("unskipped", in.run_stats->numTestCasesPassingFilters);
5451
                xml.scopedElement("OverallResultsTestSuites")
5452
                        .writeAttribute("unskipped", in.run_stats->numTestSuitesPassingFilters);
5453
            }
5454
            xml.endElement();
5455
        }
5456

5457
        void test_run_start() override {
5458
            xml.writeDeclaration();
5459

5460
            // remove .exe extension - mainly to have the same output on UNIX and Windows
5461
            std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
5462
#ifdef DOCTEST_PLATFORM_WINDOWS
5463
            if(binary_name.rfind(".exe") != std::string::npos)
5464
                binary_name = binary_name.substr(0, binary_name.length() - 4);
5465
#endif // DOCTEST_PLATFORM_WINDOWS
5466

5467
            xml.startElement("doctest").writeAttribute("binary", binary_name);
5468
            if(opt.no_version == false)
5469
                xml.writeAttribute("version", DOCTEST_VERSION_STR);
5470

5471
            // only the consequential ones (TODO: filters)
5472
            xml.scopedElement("Options")
5473
                    .writeAttribute("order_by", opt.order_by.c_str())
5474
                    .writeAttribute("rand_seed", opt.rand_seed)
5475
                    .writeAttribute("first", opt.first)
5476
                    .writeAttribute("last", opt.last)
5477
                    .writeAttribute("abort_after", opt.abort_after)
5478
                    .writeAttribute("subcase_filter_levels", opt.subcase_filter_levels)
5479
                    .writeAttribute("case_sensitive", opt.case_sensitive)
5480
                    .writeAttribute("no_throw", opt.no_throw)
5481
                    .writeAttribute("no_skip", opt.no_skip);
5482
        }
5483

5484
        void test_run_end(const TestRunStats& p) override {
5485
            if(tc) // the TestSuite tag - only if there has been at least 1 test case
5486
                xml.endElement();
5487

5488
            xml.scopedElement("OverallResultsAsserts")
5489
                    .writeAttribute("successes", p.numAsserts - p.numAssertsFailed)
5490
                    .writeAttribute("failures", p.numAssertsFailed);
5491

5492
            xml.startElement("OverallResultsTestCases")
5493
                    .writeAttribute("successes",
5494
                                    p.numTestCasesPassingFilters - p.numTestCasesFailed)
5495
                    .writeAttribute("failures", p.numTestCasesFailed);
5496
            if(opt.no_skipped_summary == false)
5497
                xml.writeAttribute("skipped", p.numTestCases - p.numTestCasesPassingFilters);
5498
            xml.endElement();
5499

5500
            xml.endElement();
5501
        }
5502

5503
        void test_case_start(const TestCaseData& in) override {
5504
            test_case_start_impl(in);
5505
            xml.ensureTagClosed();
5506
        }
5507

5508
        void test_case_reenter(const TestCaseData&) override {}
5509

5510
        void test_case_end(const CurrentTestCaseStats& st) override {
5511
            xml.startElement("OverallResultsAsserts")
5512
                    .writeAttribute("successes",
5513
                                    st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
5514
                    .writeAttribute("failures", st.numAssertsFailedCurrentTest)
5515
                    .writeAttribute("test_case_success", st.testCaseSuccess);
5516
            if(opt.duration)
5517
                xml.writeAttribute("duration", st.seconds);
5518
            if(tc->m_expected_failures)
5519
                xml.writeAttribute("expected_failures", tc->m_expected_failures);
5520
            xml.endElement();
5521

5522
            xml.endElement();
5523
        }
5524

5525
        void test_case_exception(const TestCaseException& e) override {
5526
            DOCTEST_LOCK_MUTEX(mutex)
5527

5528
            xml.scopedElement("Exception")
5529
                    .writeAttribute("crash", e.is_crash)
5530
                    .writeText(e.error_string.c_str());
5531
        }
5532

5533
        void subcase_start(const SubcaseSignature& in) override {
5534
            xml.startElement("SubCase")
5535
                    .writeAttribute("name", in.m_name)
5536
                    .writeAttribute("filename", skipPathFromFilename(in.m_file))
5537
                    .writeAttribute("line", line(in.m_line));
5538
            xml.ensureTagClosed();
5539
        }
5540

5541
        void subcase_end() override { xml.endElement(); }
5542

5543
        void log_assert(const AssertData& rb) override {
5544
            if(!rb.m_failed && !opt.success)
5545
                return;
5546

5547
            DOCTEST_LOCK_MUTEX(mutex)
5548

5549
            xml.startElement("Expression")
5550
                    .writeAttribute("success", !rb.m_failed)
5551
                    .writeAttribute("type", assertString(rb.m_at))
5552
                    .writeAttribute("filename", skipPathFromFilename(rb.m_file))
5553
                    .writeAttribute("line", line(rb.m_line));
5554

5555
            xml.scopedElement("Original").writeText(rb.m_expr);
5556

5557
            if(rb.m_threw)
5558
                xml.scopedElement("Exception").writeText(rb.m_exception.c_str());
5559

5560
            if(rb.m_at & assertType::is_throws_as)
5561
                xml.scopedElement("ExpectedException").writeText(rb.m_exception_type);
5562
            if(rb.m_at & assertType::is_throws_with)
5563
                xml.scopedElement("ExpectedExceptionString").writeText(rb.m_exception_string.c_str());
5564
            if((rb.m_at & assertType::is_normal) && !rb.m_threw)
5565
                xml.scopedElement("Expanded").writeText(rb.m_decomp.c_str());
5566

5567
            log_contexts();
5568

5569
            xml.endElement();
5570
        }
5571

5572
        void log_message(const MessageData& mb) override {
5573
            DOCTEST_LOCK_MUTEX(mutex)
5574

5575
            xml.startElement("Message")
5576
                    .writeAttribute("type", failureString(mb.m_severity))
5577
                    .writeAttribute("filename", skipPathFromFilename(mb.m_file))
5578
                    .writeAttribute("line", line(mb.m_line));
5579

5580
            xml.scopedElement("Text").writeText(mb.m_string.c_str());
5581

5582
            log_contexts();
5583

5584
            xml.endElement();
5585
        }
5586

5587
        void test_case_skipped(const TestCaseData& in) override {
5588
            if(opt.no_skipped_summary == false) {
5589
                test_case_start_impl(in);
5590
                xml.writeAttribute("skipped", "true");
5591
                xml.endElement();
5592
            }
5593
        }
5594
    };
5595

5596
    DOCTEST_REGISTER_REPORTER("xml", 0, XmlReporter);
5597

5598
    void fulltext_log_assert_to_stream(std::ostream& s, const AssertData& rb) {
5599
        if((rb.m_at & (assertType::is_throws_as | assertType::is_throws_with)) ==
5600
            0) //!OCLINT bitwise operator in conditional
5601
            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << " ) "
5602
                << Color::None;
5603

5604
        if(rb.m_at & assertType::is_throws) { //!OCLINT bitwise operator in conditional
5605
            s << (rb.m_threw ? "threw as expected!" : "did NOT throw at all!") << "\n";
5606
        } else if((rb.m_at & assertType::is_throws_as) &&
5607
                    (rb.m_at & assertType::is_throws_with)) { //!OCLINT
5608
            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
5609
                << rb.m_exception_string.c_str()
5610
                << "\", " << rb.m_exception_type << " ) " << Color::None;
5611
            if(rb.m_threw) {
5612
                if(!rb.m_failed) {
5613
                    s << "threw as expected!\n";
5614
                } else {
5615
                    s << "threw a DIFFERENT exception! (contents: " << rb.m_exception << ")\n";
5616
                }
5617
            } else {
5618
                s << "did NOT throw at all!\n";
5619
            }
5620
        } else if(rb.m_at &
5621
                    assertType::is_throws_as) { //!OCLINT bitwise operator in conditional
5622
            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", "
5623
                << rb.m_exception_type << " ) " << Color::None
5624
                << (rb.m_threw ? (rb.m_threw_as ? "threw as expected!" :
5625
                                                "threw a DIFFERENT exception: ") :
5626
                                "did NOT throw at all!")
5627
                << Color::Cyan << rb.m_exception << "\n";
5628
        } else if(rb.m_at &
5629
                    assertType::is_throws_with) { //!OCLINT bitwise operator in conditional
5630
            s << Color::Cyan << assertString(rb.m_at) << "( " << rb.m_expr << ", \""
5631
                << rb.m_exception_string.c_str()
5632
                << "\" ) " << Color::None
5633
                << (rb.m_threw ? (!rb.m_failed ? "threw as expected!" :
5634
                                                "threw a DIFFERENT exception: ") :
5635
                                "did NOT throw at all!")
5636
                << Color::Cyan << rb.m_exception << "\n";
5637
        } else if(rb.m_at & assertType::is_nothrow) { //!OCLINT bitwise operator in conditional
5638
            s << (rb.m_threw ? "THREW exception: " : "didn't throw!") << Color::Cyan
5639
                << rb.m_exception << "\n";
5640
        } else {
5641
            s << (rb.m_threw ? "THREW exception: " :
5642
                                (!rb.m_failed ? "is correct!\n" : "is NOT correct!\n"));
5643
            if(rb.m_threw)
5644
                s << rb.m_exception << "\n";
5645
            else
5646
                s << "  values: " << assertString(rb.m_at) << "( " << rb.m_decomp << " )\n";
5647
        }
5648
    }
5649

5650
    // TODO:
5651
    // - log_message()
5652
    // - respond to queries
5653
    // - honor remaining options
5654
    // - more attributes in tags
5655
    struct JUnitReporter : public IReporter
5656
    {
5657
        XmlWriter xml;
5658
        DOCTEST_DECLARE_MUTEX(mutex)
5659
        Timer timer;
5660
        std::vector<String> deepestSubcaseStackNames;
5661

5662
        struct JUnitTestCaseData
5663
        {
5664
            static std::string getCurrentTimestamp() {
5665
                // Beware, this is not reentrant because of backward compatibility issues
5666
                // Also, UTC only, again because of backward compatibility (%z is C++11)
5667
                time_t rawtime;
5668
                std::time(&rawtime);
5669
                auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
5670

5671
                std::tm timeInfo;
5672
#ifdef DOCTEST_PLATFORM_WINDOWS
5673
                gmtime_s(&timeInfo, &rawtime);
5674
#elif defined(DOCTEST_CONFIG_USE_GMTIME_S)
5675
                gmtime_s(&rawtime, &timeInfo);
5676
#else // DOCTEST_PLATFORM_WINDOWS
5677
                gmtime_r(&rawtime, &timeInfo);
5678
#endif // DOCTEST_PLATFORM_WINDOWS
5679

5680
                char timeStamp[timeStampSize];
5681
                const char* const fmt = "%Y-%m-%dT%H:%M:%SZ";
5682

5683
                std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
5684
                return std::string(timeStamp);
5685
            }
5686

5687
            struct JUnitTestMessage
5688
            {
5689
                JUnitTestMessage(const std::string& _message, const std::string& _type, const std::string& _details)
5690
                    : message(_message), type(_type), details(_details) {}
5691

5692
                JUnitTestMessage(const std::string& _message, const std::string& _details)
5693
                    : message(_message), type(), details(_details) {}
5694

5695
                std::string message, type, details;
5696
            };
5697

5698
            struct JUnitTestCase
5699
            {
5700
                JUnitTestCase(const std::string& _classname, const std::string& _name)
5701
                    : classname(_classname), name(_name), time(0), failures() {}
5702

5703
                std::string classname, name;
5704
                double time;
5705
                std::vector<JUnitTestMessage> failures, errors;
5706
            };
5707

5708
            void add(const std::string& classname, const std::string& name) {
5709
                testcases.emplace_back(classname, name);
5710
            }
5711

5712
            void appendSubcaseNamesToLastTestcase(std::vector<String> nameStack) {
5713
                for(auto& curr: nameStack)
5714
                    if(curr.size())
5715
                        testcases.back().name += std::string("/") + curr.c_str();
5716
            }
5717

5718
            void addTime(double time) {
5719
                if(time < 1e-4)
5720
                    time = 0;
5721
                testcases.back().time = time;
5722
                totalSeconds += time;
5723
            }
5724

5725
            void addFailure(const std::string& message, const std::string& type, const std::string& details) {
5726
                testcases.back().failures.emplace_back(message, type, details);
5727
                ++totalFailures;
5728
            }
5729

5730
            void addError(const std::string& message, const std::string& details) {
5731
                testcases.back().errors.emplace_back(message, details);
5732
                ++totalErrors;
5733
            }
5734

5735
            std::vector<JUnitTestCase> testcases;
5736
            double totalSeconds = 0;
5737
            int totalErrors = 0, totalFailures = 0;
5738
        };
5739

5740
        JUnitTestCaseData testCaseData;
5741

5742
        // caching pointers/references to objects of these types - safe to do
5743
        const ContextOptions& opt;
5744
        const TestCaseData*   tc = nullptr;
5745

5746
        JUnitReporter(const ContextOptions& co)
5747
                : xml(*co.cout)
5748
                , opt(co) {}
5749

5750
        unsigned line(unsigned l) const { return opt.no_line_numbers ? 0 : l; }
5751

5752
        // =========================================================================================
5753
        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
5754
        // =========================================================================================
5755

5756
        void report_query(const QueryData&) override {
5757
            xml.writeDeclaration();
5758
        }
5759

5760
        void test_run_start() override {
5761
            xml.writeDeclaration();
5762
        }
5763

5764
        void test_run_end(const TestRunStats& p) override {
5765
            // remove .exe extension - mainly to have the same output on UNIX and Windows
5766
            std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
5767
#ifdef DOCTEST_PLATFORM_WINDOWS
5768
            if(binary_name.rfind(".exe") != std::string::npos)
5769
                binary_name = binary_name.substr(0, binary_name.length() - 4);
5770
#endif // DOCTEST_PLATFORM_WINDOWS
5771
            xml.startElement("testsuites");
5772
            xml.startElement("testsuite").writeAttribute("name", binary_name)
5773
                    .writeAttribute("errors", testCaseData.totalErrors)
5774
                    .writeAttribute("failures", testCaseData.totalFailures)
5775
                    .writeAttribute("tests", p.numAsserts);
5776
            if(opt.no_time_in_output == false) {
5777
                xml.writeAttribute("time", testCaseData.totalSeconds);
5778
                xml.writeAttribute("timestamp", JUnitTestCaseData::getCurrentTimestamp());
5779
            }
5780
            if(opt.no_version == false)
5781
                xml.writeAttribute("doctest_version", DOCTEST_VERSION_STR);
5782

5783
            for(const auto& testCase : testCaseData.testcases) {
5784
                xml.startElement("testcase")
5785
                    .writeAttribute("classname", testCase.classname)
5786
                    .writeAttribute("name", testCase.name);
5787
                if(opt.no_time_in_output == false)
5788
                    xml.writeAttribute("time", testCase.time);
5789
                // This is not ideal, but it should be enough to mimic gtest's junit output.
5790
                xml.writeAttribute("status", "run");
5791

5792
                for(const auto& failure : testCase.failures) {
5793
                    xml.scopedElement("failure")
5794
                        .writeAttribute("message", failure.message)
5795
                        .writeAttribute("type", failure.type)
5796
                        .writeText(failure.details, false);
5797
                }
5798

5799
                for(const auto& error : testCase.errors) {
5800
                    xml.scopedElement("error")
5801
                        .writeAttribute("message", error.message)
5802
                        .writeText(error.details);
5803
                }
5804

5805
                xml.endElement();
5806
            }
5807
            xml.endElement();
5808
            xml.endElement();
5809
        }
5810

5811
        void test_case_start(const TestCaseData& in) override {
5812
            testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
5813
            timer.start();
5814
        }
5815

5816
        void test_case_reenter(const TestCaseData& in) override {
5817
            testCaseData.addTime(timer.getElapsedSeconds());
5818
            testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
5819
            deepestSubcaseStackNames.clear();
5820

5821
            timer.start();
5822
            testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
5823
        }
5824

5825
        void test_case_end(const CurrentTestCaseStats&) override {
5826
            testCaseData.addTime(timer.getElapsedSeconds());
5827
            testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
5828
            deepestSubcaseStackNames.clear();
5829
        }
5830

5831
        void test_case_exception(const TestCaseException& e) override {
5832
            DOCTEST_LOCK_MUTEX(mutex)
5833
            testCaseData.addError("exception", e.error_string.c_str());
5834
        }
5835

5836
        void subcase_start(const SubcaseSignature& in) override {
5837
            deepestSubcaseStackNames.push_back(in.m_name);
5838
        }
5839

5840
        void subcase_end() override {}
5841

5842
        void log_assert(const AssertData& rb) override {
5843
            if(!rb.m_failed) // report only failures & ignore the `success` option
5844
                return;
5845

5846
            DOCTEST_LOCK_MUTEX(mutex)
5847

5848
            std::ostringstream os;
5849
            os << skipPathFromFilename(rb.m_file) << (opt.gnu_file_line ? ":" : "(")
5850
              << line(rb.m_line) << (opt.gnu_file_line ? ":" : "):") << std::endl;
5851

5852
            fulltext_log_assert_to_stream(os, rb);
5853
            log_contexts(os);
5854
            testCaseData.addFailure(rb.m_decomp.c_str(), assertString(rb.m_at), os.str());
5855
        }
5856

5857
        void log_message(const MessageData&) override {}
5858

5859
        void test_case_skipped(const TestCaseData&) override {}
5860

5861
        void log_contexts(std::ostringstream& s) {
5862
            int num_contexts = get_num_active_contexts();
5863
            if(num_contexts) {
5864
                auto contexts = get_active_contexts();
5865

5866
                s << "  logged: ";
5867
                for(int i = 0; i < num_contexts; ++i) {
5868
                    s << (i == 0 ? "" : "          ");
5869
                    contexts[i]->stringify(&s);
5870
                    s << std::endl;
5871
                }
5872
            }
5873
        }
5874
    };
5875

5876
    DOCTEST_REGISTER_REPORTER("junit", 0, JUnitReporter);
5877

5878
    struct Whitespace
5879
    {
5880
        int nrSpaces;
5881
        explicit Whitespace(int nr)
5882
                : nrSpaces(nr) {}
5883
    };
5884

5885
    std::ostream& operator<<(std::ostream& out, const Whitespace& ws) {
5886
        if(ws.nrSpaces != 0)
5887
            out << std::setw(ws.nrSpaces) << ' ';
5888
        return out;
5889
    }
5890

5891
    struct ConsoleReporter : public IReporter
5892
    {
5893
        std::ostream&                 s;
5894
        bool                          hasLoggedCurrentTestStart;
5895
        std::vector<SubcaseSignature> subcasesStack;
5896
        size_t                        currentSubcaseLevel;
5897
        DOCTEST_DECLARE_MUTEX(mutex)
5898

5899
        // caching pointers/references to objects of these types - safe to do
5900
        const ContextOptions& opt;
5901
        const TestCaseData*   tc;
5902

5903
        ConsoleReporter(const ContextOptions& co)
5904
                : s(*co.cout)
5905
                , opt(co) {}
5906

5907
        ConsoleReporter(const ContextOptions& co, std::ostream& ostr)
5908
                : s(ostr)
5909
                , opt(co) {}
5910

5911
        // =========================================================================================
5912
        // WHAT FOLLOWS ARE HELPERS USED BY THE OVERRIDES OF THE VIRTUAL METHODS OF THE INTERFACE
5913
        // =========================================================================================
5914

5915
        void separator_to_stream() {
5916
            s << Color::Yellow
5917
              << "==============================================================================="
5918
                 "\n";
5919
        }
5920

5921
        const char* getSuccessOrFailString(bool success, assertType::Enum at,
5922
                                           const char* success_str) {
5923
            if(success)
5924
                return success_str;
5925
            return failureString(at);
5926
        }
5927

5928
        Color::Enum getSuccessOrFailColor(bool success, assertType::Enum at) {
5929
            return success ? Color::BrightGreen :
5930
                             (at & assertType::is_warn) ? Color::Yellow : Color::Red;
5931
        }
5932

5933
        void successOrFailColoredStringToStream(bool success, assertType::Enum at,
5934
                                                const char* success_str = "SUCCESS") {
5935
            s << getSuccessOrFailColor(success, at)
5936
              << getSuccessOrFailString(success, at, success_str) << ": ";
5937
        }
5938

5939
        void log_contexts() {
5940
            int num_contexts = get_num_active_contexts();
5941
            if(num_contexts) {
5942
                auto contexts = get_active_contexts();
5943

5944
                s << Color::None << "  logged: ";
5945
                for(int i = 0; i < num_contexts; ++i) {
5946
                    s << (i == 0 ? "" : "          ");
5947
                    contexts[i]->stringify(&s);
5948
                    s << "\n";
5949
                }
5950
            }
5951

5952
            s << "\n";
5953
        }
5954

5955
        // this was requested to be made virtual so users could override it
5956
        virtual void file_line_to_stream(const char* file, int line,
5957
                                        const char* tail = "") {
5958
            s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
5959
            << (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option
5960
            << (opt.gnu_file_line ? ":" : "):") << tail;
5961
        }
5962

5963
        void logTestStart() {
5964
            if(hasLoggedCurrentTestStart)
5965
                return;
5966

5967
            separator_to_stream();
5968
            file_line_to_stream(tc->m_file.c_str(), tc->m_line, "\n");
5969
            if(tc->m_description)
5970
                s << Color::Yellow << "DESCRIPTION: " << Color::None << tc->m_description << "\n";
5971
            if(tc->m_test_suite && tc->m_test_suite[0] != '\0')
5972
                s << Color::Yellow << "TEST SUITE: " << Color::None << tc->m_test_suite << "\n";
5973
            if(strncmp(tc->m_name, "  Scenario:", 11) != 0)
5974
                s << Color::Yellow << "TEST CASE:  ";
5975
            s << Color::None << tc->m_name << "\n";
5976

5977
            for(size_t i = 0; i < currentSubcaseLevel; ++i) {
5978
                if(subcasesStack[i].m_name[0] != '\0')
5979
                    s << "  " << subcasesStack[i].m_name << "\n";
5980
            }
5981

5982
            if(currentSubcaseLevel != subcasesStack.size()) {
5983
                s << Color::Yellow << "\nDEEPEST SUBCASE STACK REACHED (DIFFERENT FROM THE CURRENT ONE):\n" << Color::None;
5984
                for(size_t i = 0; i < subcasesStack.size(); ++i) {
5985
                    if(subcasesStack[i].m_name[0] != '\0')
5986
                        s << "  " << subcasesStack[i].m_name << "\n";
5987
                }
5988
            }
5989

5990
            s << "\n";
5991

5992
            hasLoggedCurrentTestStart = true;
5993
        }
5994

5995
        void printVersion() {
5996
            if(opt.no_version == false)
5997
                s << Color::Cyan << "[doctest] " << Color::None << "doctest version is \""
5998
                  << DOCTEST_VERSION_STR << "\"\n";
5999
        }
6000

6001
        void printIntro() {
6002
            if(opt.no_intro == false) {
6003
                printVersion();
6004
                s << Color::Cyan << "[doctest] " << Color::None
6005
                  << "run with \"--" DOCTEST_OPTIONS_PREFIX_DISPLAY "help\" for options\n";
6006
            }
6007
        }
6008

6009
        void printHelp() {
6010
            int sizePrefixDisplay = static_cast<int>(strlen(DOCTEST_OPTIONS_PREFIX_DISPLAY));
6011
            printVersion();
6012
            // clang-format off
6013
            s << Color::Cyan << "[doctest]\n" << Color::None;
6014
            s << Color::Cyan << "[doctest] " << Color::None;
6015
            s << "boolean values: \"1/on/yes/true\" or \"0/off/no/false\"\n";
6016
            s << Color::Cyan << "[doctest] " << Color::None;
6017
            s << "filter  values: \"str1,str2,str3\" (comma separated strings)\n";
6018
            s << Color::Cyan << "[doctest]\n" << Color::None;
6019
            s << Color::Cyan << "[doctest] " << Color::None;
6020
            s << "filters use wildcards for matching strings\n";
6021
            s << Color::Cyan << "[doctest] " << Color::None;
6022
            s << "something passes a filter if any of the strings in a filter matches\n";
6023
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
6024
            s << Color::Cyan << "[doctest]\n" << Color::None;
6025
            s << Color::Cyan << "[doctest] " << Color::None;
6026
            s << "ALL FLAGS, OPTIONS AND FILTERS ALSO AVAILABLE WITH A \"" DOCTEST_CONFIG_OPTIONS_PREFIX "\" PREFIX!!!\n";
6027
#endif
6028
            s << Color::Cyan << "[doctest]\n" << Color::None;
6029
            s << Color::Cyan << "[doctest] " << Color::None;
6030
            s << "Query flags - the program quits after them. Available:\n\n";
6031
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "?,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "help, -" DOCTEST_OPTIONS_PREFIX_DISPLAY "h                      "
6032
              << Whitespace(sizePrefixDisplay*0) <<  "prints this message\n";
6033
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "v,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "version                       "
6034
              << Whitespace(sizePrefixDisplay*1) << "prints the version\n";
6035
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "c,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "count                         "
6036
              << Whitespace(sizePrefixDisplay*1) << "prints the number of matching tests\n";
6037
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ltc, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-cases               "
6038
              << Whitespace(sizePrefixDisplay*1) << "lists all matching tests by name\n";
6039
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lts, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-test-suites              "
6040
              << Whitespace(sizePrefixDisplay*1) << "lists all matching test suites\n";
6041
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "lr,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "list-reporters                "
6042
              << Whitespace(sizePrefixDisplay*1) << "lists all registered reporters\n\n";
6043
            // ================================================================================== << 79
6044
            s << Color::Cyan << "[doctest] " << Color::None;
6045
            s << "The available <int>/<string> options/filters are:\n\n";
6046
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case=<filters>           "
6047
              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their name\n";
6048
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-case-exclude=<filters>   "
6049
              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their name\n";
6050
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sf,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file=<filters>         "
6051
              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their file\n";
6052
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sfe, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "source-file-exclude=<filters> "
6053
              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their file\n";
6054
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ts,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite=<filters>          "
6055
              << Whitespace(sizePrefixDisplay*1) << "filters     tests by their test suite\n";
6056
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "tse, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "test-suite-exclude=<filters>  "
6057
              << Whitespace(sizePrefixDisplay*1) << "filters OUT tests by their test suite\n";
6058
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase=<filters>             "
6059
              << Whitespace(sizePrefixDisplay*1) << "filters     subcases by their name\n";
6060
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "sce, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-exclude=<filters>     "
6061
              << Whitespace(sizePrefixDisplay*1) << "filters OUT subcases by their name\n";
6062
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "r,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "reporters=<filters>           "
6063
              << Whitespace(sizePrefixDisplay*1) << "reporters to use (console is default)\n";
6064
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "o,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "out=<string>                  "
6065
              << Whitespace(sizePrefixDisplay*1) << "output filename\n";
6066
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ob,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "order-by=<string>             "
6067
              << Whitespace(sizePrefixDisplay*1) << "how the tests should be ordered\n";
6068
            s << Whitespace(sizePrefixDisplay*3) << "                                       <string> - [file/suite/name/rand/none]\n";
6069
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "rs,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "rand-seed=<int>               "
6070
              << Whitespace(sizePrefixDisplay*1) << "seed for random ordering\n";
6071
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "f,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "first=<int>                   "
6072
              << Whitespace(sizePrefixDisplay*1) << "the first test passing the filters to\n";
6073
            s << Whitespace(sizePrefixDisplay*3) << "                                       execute - for range-based execution\n";
6074
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "l,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "last=<int>                    "
6075
              << Whitespace(sizePrefixDisplay*1) << "the last test passing the filters to\n";
6076
            s << Whitespace(sizePrefixDisplay*3) << "                                       execute - for range-based execution\n";
6077
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "aa,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "abort-after=<int>             "
6078
              << Whitespace(sizePrefixDisplay*1) << "stop after <int> failed assertions\n";
6079
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "scfl,--" DOCTEST_OPTIONS_PREFIX_DISPLAY "subcase-filter-levels=<int>   "
6080
              << Whitespace(sizePrefixDisplay*1) << "apply filters for the first <int> levels\n";
6081
            s << Color::Cyan << "\n[doctest] " << Color::None;
6082
            s << "Bool options - can be used like flags and true is assumed. Available:\n\n";
6083
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "s,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "success=<bool>                "
6084
              << Whitespace(sizePrefixDisplay*1) << "include successful assertions in output\n";
6085
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "cs,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "case-sensitive=<bool>         "
6086
              << Whitespace(sizePrefixDisplay*1) << "filters being treated as case sensitive\n";
6087
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "e,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "exit=<bool>                   "
6088
              << Whitespace(sizePrefixDisplay*1) << "exits after the tests finish\n";
6089
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "d,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "duration=<bool>               "
6090
              << Whitespace(sizePrefixDisplay*1) << "prints the time duration of each test\n";
6091
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "m,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "minimal=<bool>                "
6092
              << Whitespace(sizePrefixDisplay*1) << "minimal console output (only failures)\n";
6093
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "q,   --" DOCTEST_OPTIONS_PREFIX_DISPLAY "quiet=<bool>                  "
6094
              << Whitespace(sizePrefixDisplay*1) << "no console output\n";
6095
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nt,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-throw=<bool>               "
6096
              << Whitespace(sizePrefixDisplay*1) << "skips exceptions-related assert checks\n";
6097
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ne,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-exitcode=<bool>            "
6098
              << Whitespace(sizePrefixDisplay*1) << "returns (or exits) always with success\n";
6099
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nr,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-run=<bool>                 "
6100
              << Whitespace(sizePrefixDisplay*1) << "skips all runtime doctest operations\n";
6101
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ni,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-intro=<bool>               "
6102
              << Whitespace(sizePrefixDisplay*1) << "omit the framework intro in the output\n";
6103
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nv,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-version=<bool>             "
6104
              << Whitespace(sizePrefixDisplay*1) << "omit the framework version in the output\n";
6105
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-colors=<bool>              "
6106
              << Whitespace(sizePrefixDisplay*1) << "disables colors in output\n";
6107
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "fc,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "force-colors=<bool>           "
6108
              << Whitespace(sizePrefixDisplay*1) << "use colors even when not in a tty\n";
6109
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nb,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-breaks=<bool>              "
6110
              << Whitespace(sizePrefixDisplay*1) << "disables breakpoints in debuggers\n";
6111
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "ns,  --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-skip=<bool>                "
6112
              << Whitespace(sizePrefixDisplay*1) << "don't skip test cases marked as skip\n";
6113
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "gfl, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "gnu-file-line=<bool>          "
6114
              << Whitespace(sizePrefixDisplay*1) << ":n: vs (n): for line numbers in output\n";
6115
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "npf, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-path-filenames=<bool>      "
6116
              << Whitespace(sizePrefixDisplay*1) << "only filenames and no paths in output\n";
6117
            s << " -" DOCTEST_OPTIONS_PREFIX_DISPLAY "nln, --" DOCTEST_OPTIONS_PREFIX_DISPLAY "no-line-numbers=<bool>        "
6118
              << Whitespace(sizePrefixDisplay*1) << "0 instead of real line numbers in output\n";
6119
            // ================================================================================== << 79
6120
            // clang-format on
6121

6122
            s << Color::Cyan << "\n[doctest] " << Color::None;
6123
            s << "for more information visit the project documentation\n\n";
6124
        }
6125

6126
        void printRegisteredReporters() {
6127
            printVersion();
6128
            auto printReporters = [this] (const reporterMap& reporters, const char* type) {
6129
                if(reporters.size()) {
6130
                    s << Color::Cyan << "[doctest] " << Color::None << "listing all registered " << type << "\n";
6131
                    for(auto& curr : reporters)
6132
                        s << "priority: " << std::setw(5) << curr.first.first
6133
                          << " name: " << curr.first.second << "\n";
6134
                }
6135
            };
6136
            printReporters(getListeners(), "listeners");
6137
            printReporters(getReporters(), "reporters");
6138
        }
6139

6140
        // =========================================================================================
6141
        // WHAT FOLLOWS ARE OVERRIDES OF THE VIRTUAL METHODS OF THE REPORTER INTERFACE
6142
        // =========================================================================================
6143

6144
        void report_query(const QueryData& in) override {
6145
            if(opt.version) {
6146
                printVersion();
6147
            } else if(opt.help) {
6148
                printHelp();
6149
            } else if(opt.list_reporters) {
6150
                printRegisteredReporters();
6151
            } else if(opt.count || opt.list_test_cases) {
6152
                if(opt.list_test_cases) {
6153
                    s << Color::Cyan << "[doctest] " << Color::None
6154
                      << "listing all test case names\n";
6155
                    separator_to_stream();
6156
                }
6157

6158
                for(unsigned i = 0; i < in.num_data; ++i)
6159
                    s << Color::None << in.data[i]->m_name << "\n";
6160

6161
                separator_to_stream();
6162

6163
                s << Color::Cyan << "[doctest] " << Color::None
6164
                  << "unskipped test cases passing the current filters: "
6165
                  << g_cs->numTestCasesPassingFilters << "\n";
6166

6167
            } else if(opt.list_test_suites) {
6168
                s << Color::Cyan << "[doctest] " << Color::None << "listing all test suites\n";
6169
                separator_to_stream();
6170

6171
                for(unsigned i = 0; i < in.num_data; ++i)
6172
                    s << Color::None << in.data[i]->m_test_suite << "\n";
6173

6174
                separator_to_stream();
6175

6176
                s << Color::Cyan << "[doctest] " << Color::None
6177
                  << "unskipped test cases passing the current filters: "
6178
                  << g_cs->numTestCasesPassingFilters << "\n";
6179
                s << Color::Cyan << "[doctest] " << Color::None
6180
                  << "test suites with unskipped test cases passing the current filters: "
6181
                  << g_cs->numTestSuitesPassingFilters << "\n";
6182
            }
6183
        }
6184

6185
        void test_run_start() override {
6186
            if(!opt.minimal)
6187
                printIntro();
6188
        }
6189

6190
        void test_run_end(const TestRunStats& p) override {
6191
            if(opt.minimal && p.numTestCasesFailed == 0)
6192
                return;
6193

6194
            separator_to_stream();
6195
            s << std::dec;
6196

6197
            auto totwidth = int(std::ceil(log10((std::max(p.numTestCasesPassingFilters, static_cast<unsigned>(p.numAsserts))) + 1)));
6198
            auto passwidth = int(std::ceil(log10((std::max(p.numTestCasesPassingFilters - p.numTestCasesFailed, static_cast<unsigned>(p.numAsserts - p.numAssertsFailed))) + 1)));
6199
            auto failwidth = int(std::ceil(log10((std::max(p.numTestCasesFailed, static_cast<unsigned>(p.numAssertsFailed))) + 1)));
6200
            const bool anythingFailed = p.numTestCasesFailed > 0 || p.numAssertsFailed > 0;
6201
            s << Color::Cyan << "[doctest] " << Color::None << "test cases: " << std::setw(totwidth)
6202
              << p.numTestCasesPassingFilters << " | "
6203
              << ((p.numTestCasesPassingFilters == 0 || anythingFailed) ? Color::None :
6204
                                                                          Color::Green)
6205
              << std::setw(passwidth) << p.numTestCasesPassingFilters - p.numTestCasesFailed << " passed"
6206
              << Color::None << " | " << (p.numTestCasesFailed > 0 ? Color::Red : Color::None)
6207
              << std::setw(failwidth) << p.numTestCasesFailed << " failed" << Color::None << " |";
6208
            if(opt.no_skipped_summary == false) {
6209
                const int numSkipped = p.numTestCases - p.numTestCasesPassingFilters;
6210
                s << " " << (numSkipped == 0 ? Color::None : Color::Yellow) << numSkipped
6211
                  << " skipped" << Color::None;
6212
            }
6213
            s << "\n";
6214
            s << Color::Cyan << "[doctest] " << Color::None << "assertions: " << std::setw(totwidth)
6215
              << p.numAsserts << " | "
6216
              << ((p.numAsserts == 0 || anythingFailed) ? Color::None : Color::Green)
6217
              << std::setw(passwidth) << (p.numAsserts - p.numAssertsFailed) << " passed" << Color::None
6218
              << " | " << (p.numAssertsFailed > 0 ? Color::Red : Color::None) << std::setw(failwidth)
6219
              << p.numAssertsFailed << " failed" << Color::None << " |\n";
6220
            s << Color::Cyan << "[doctest] " << Color::None
6221
              << "Status: " << (p.numTestCasesFailed > 0 ? Color::Red : Color::Green)
6222
              << ((p.numTestCasesFailed > 0) ? "FAILURE!" : "SUCCESS!") << Color::None << std::endl;
6223
        }
6224

6225
        void test_case_start(const TestCaseData& in) override {
6226
            hasLoggedCurrentTestStart = false;
6227
            tc                        = &in;
6228
            subcasesStack.clear();
6229
            currentSubcaseLevel = 0;
6230
        }
6231

6232
        void test_case_reenter(const TestCaseData&) override {
6233
            subcasesStack.clear();
6234
        }
6235

6236
        void test_case_end(const CurrentTestCaseStats& st) override {
6237
            if(tc->m_no_output)
6238
                return;
6239

6240
            // log the preamble of the test case only if there is something
6241
            // else to print - something other than that an assert has failed
6242
            if(opt.duration ||
6243
               (st.failure_flags && st.failure_flags != static_cast<int>(TestCaseFailureReason::AssertFailure)))
6244
                logTestStart();
6245

6246
            if(opt.duration)
6247
                s << Color::None << std::setprecision(6) << std::fixed << st.seconds
6248
                  << " s: " << tc->m_name << "\n";
6249

6250
            if(st.failure_flags & TestCaseFailureReason::Timeout)
6251
                s << Color::Red << "Test case exceeded time limit of " << std::setprecision(6)
6252
                  << std::fixed << tc->m_timeout << "!\n";
6253

6254
            if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedButDidnt) {
6255
                s << Color::Red << "Should have failed but didn't! Marking it as failed!\n";
6256
            } else if(st.failure_flags & TestCaseFailureReason::ShouldHaveFailedAndDid) {
6257
                s << Color::Yellow << "Failed as expected so marking it as not failed\n";
6258
            } else if(st.failure_flags & TestCaseFailureReason::CouldHaveFailedAndDid) {
6259
                s << Color::Yellow << "Allowed to fail so marking it as not failed\n";
6260
            } else if(st.failure_flags & TestCaseFailureReason::DidntFailExactlyNumTimes) {
6261
                s << Color::Red << "Didn't fail exactly " << tc->m_expected_failures
6262
                  << " times so marking it as failed!\n";
6263
            } else if(st.failure_flags & TestCaseFailureReason::FailedExactlyNumTimes) {
6264
                s << Color::Yellow << "Failed exactly " << tc->m_expected_failures
6265
                  << " times as expected so marking it as not failed!\n";
6266
            }
6267
            if(st.failure_flags & TestCaseFailureReason::TooManyFailedAsserts) {
6268
                s << Color::Red << "Aborting - too many failed asserts!\n";
6269
            }
6270
            s << Color::None; // lgtm [cpp/useless-expression]
6271
        }
6272

6273
        void test_case_exception(const TestCaseException& e) override {
6274
            DOCTEST_LOCK_MUTEX(mutex)
6275
            if(tc->m_no_output)
6276
                return;
6277

6278
            logTestStart();
6279

6280
            file_line_to_stream(tc->m_file.c_str(), tc->m_line, " ");
6281
            successOrFailColoredStringToStream(false, e.is_crash ? assertType::is_require :
6282
                                                                   assertType::is_check);
6283
            s << Color::Red << (e.is_crash ? "test case CRASHED: " : "test case THREW exception: ")
6284
              << Color::Cyan << e.error_string << "\n";
6285

6286
            int num_stringified_contexts = get_num_stringified_contexts();
6287
            if(num_stringified_contexts) {
6288
                auto stringified_contexts = get_stringified_contexts();
6289
                s << Color::None << "  logged: ";
6290
                for(int i = num_stringified_contexts; i > 0; --i) {
6291
                    s << (i == num_stringified_contexts ? "" : "          ")
6292
                      << stringified_contexts[i - 1] << "\n";
6293
                }
6294
            }
6295
            s << "\n" << Color::None;
6296
        }
6297

6298
        void subcase_start(const SubcaseSignature& subc) override {
6299
            subcasesStack.push_back(subc);
6300
            ++currentSubcaseLevel;
6301
            hasLoggedCurrentTestStart = false;
6302
        }
6303

6304
        void subcase_end() override {
6305
            --currentSubcaseLevel;
6306
            hasLoggedCurrentTestStart = false;
6307
        }
6308

6309
        void log_assert(const AssertData& rb) override {
6310
            if((!rb.m_failed && !opt.success) || tc->m_no_output)
6311
                return;
6312

6313
            DOCTEST_LOCK_MUTEX(mutex)
6314

6315
            logTestStart();
6316

6317
            file_line_to_stream(rb.m_file, rb.m_line, " ");
6318
            successOrFailColoredStringToStream(!rb.m_failed, rb.m_at);
6319

6320
            fulltext_log_assert_to_stream(s, rb);
6321

6322
            log_contexts();
6323
        }
6324

6325
        void log_message(const MessageData& mb) override {
6326
            if(tc->m_no_output)
6327
                return;
6328

6329
            DOCTEST_LOCK_MUTEX(mutex)
6330

6331
            logTestStart();
6332

6333
            file_line_to_stream(mb.m_file, mb.m_line, " ");
6334
            s << getSuccessOrFailColor(false, mb.m_severity)
6335
              << getSuccessOrFailString(mb.m_severity & assertType::is_warn, mb.m_severity,
6336
                                        "MESSAGE") << ": ";
6337
            s << Color::None << mb.m_string << "\n";
6338
            log_contexts();
6339
        }
6340

6341
        void test_case_skipped(const TestCaseData&) override {}
6342
    };
6343

6344
    DOCTEST_REGISTER_REPORTER("console", 0, ConsoleReporter);
6345

6346
#ifdef DOCTEST_PLATFORM_WINDOWS
6347
    struct DebugOutputWindowReporter : public ConsoleReporter
6348
    {
6349
        DOCTEST_THREAD_LOCAL static std::ostringstream oss;
6350

6351
        DebugOutputWindowReporter(const ContextOptions& co)
6352
                : ConsoleReporter(co, oss) {}
6353

6354
#define DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(func, type, arg)                                    \
6355
    void func(type arg) override {                                                                 \
6356
        bool with_col = g_no_colors;                                                               \
6357
        g_no_colors   = false;                                                                     \
6358
        ConsoleReporter::func(arg);                                                                \
6359
        if(oss.tellp() != std::streampos{}) {                                                      \
6360
            DOCTEST_OUTPUT_DEBUG_STRING(oss.str().c_str());                                        \
6361
            oss.str("");                                                                           \
6362
        }                                                                                          \
6363
        g_no_colors = with_col;                                                                    \
6364
    }
6365

6366
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_start, DOCTEST_EMPTY, DOCTEST_EMPTY)
6367
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_run_end, const TestRunStats&, in)
6368
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_start, const TestCaseData&, in)
6369
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_reenter, const TestCaseData&, in)
6370
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_end, const CurrentTestCaseStats&, in)
6371
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_exception, const TestCaseException&, in)
6372
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_start, const SubcaseSignature&, in)
6373
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(subcase_end, DOCTEST_EMPTY, DOCTEST_EMPTY)
6374
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_assert, const AssertData&, in)
6375
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(log_message, const MessageData&, in)
6376
        DOCTEST_DEBUG_OUTPUT_REPORTER_OVERRIDE(test_case_skipped, const TestCaseData&, in)
6377
    };
6378

6379
    DOCTEST_THREAD_LOCAL std::ostringstream DebugOutputWindowReporter::oss;
6380
#endif // DOCTEST_PLATFORM_WINDOWS
6381

6382
    // the implementation of parseOption()
6383
    bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
6384
        // going from the end to the beginning and stopping on the first occurrence from the end
6385
        for(int i = argc; i > 0; --i) {
6386
            auto index = i - 1;
6387
            auto temp = std::strstr(argv[index], pattern);
6388
            if(temp && (value || strlen(temp) == strlen(pattern))) { //!OCLINT prefer early exits and continue
6389
                // eliminate matches in which the chars before the option are not '-'
6390
                bool noBadCharsFound = true;
6391
                auto curr            = argv[index];
6392
                while(curr != temp) {
6393
                    if(*curr++ != '-') {
6394
                        noBadCharsFound = false;
6395
                        break;
6396
                    }
6397
                }
6398
                if(noBadCharsFound && argv[index][0] == '-') {
6399
                    if(value) {
6400
                        // parsing the value of an option
6401
                        temp += strlen(pattern);
6402
                        const unsigned len = strlen(temp);
6403
                        if(len) {
6404
                            *value = temp;
6405
                            return true;
6406
                        }
6407
                    } else {
6408
                        // just a flag - no value
6409
                        return true;
6410
                    }
6411
                }
6412
            }
6413
        }
6414
        return false;
6415
    }
6416

6417
    // parses an option and returns the string after the '=' character
6418
    bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
6419
                     const String& defaultVal = String()) {
6420
        if(value)
6421
            *value = defaultVal;
6422
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
6423
        // offset (normally 3 for "dt-") to skip prefix
6424
        if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value))
6425
            return true;
6426
#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
6427
        return parseOptionImpl(argc, argv, pattern, value);
6428
    }
6429

6430
    // locates a flag on the command line
6431
    bool parseFlag(int argc, const char* const* argv, const char* pattern) {
6432
        return parseOption(argc, argv, pattern);
6433
    }
6434

6435
    // parses a comma separated list of words after a pattern in one of the arguments in argv
6436
    bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern,
6437
                           std::vector<String>& res) {
6438
        String filtersString;
6439
        if(parseOption(argc, argv, pattern, &filtersString)) {
6440
            // tokenize with "," as a separator, unless escaped with backslash
6441
            std::ostringstream s;
6442
            auto flush = [&s, &res]() {
6443
                auto string = s.str();
6444
                if(string.size() > 0) {
6445
                    res.push_back(string.c_str());
6446
                }
6447
                s.str("");
6448
            };
6449

6450
            bool seenBackslash = false;
6451
            const char* current = filtersString.c_str();
6452
            const char* end = current + strlen(current);
6453
            while(current != end) {
6454
                char character = *current++;
6455
                if(seenBackslash) {
6456
                    seenBackslash = false;
6457
                    if(character == ',' || character == '\\') {
6458
                        s.put(character);
6459
                        continue;
6460
                    }
6461
                    s.put('\\');
6462
                }
6463
                if(character == '\\') {
6464
                    seenBackslash = true;
6465
                } else if(character == ',') {
6466
                    flush();
6467
                } else {
6468
                    s.put(character);
6469
                }
6470
            }
6471

6472
            if(seenBackslash) {
6473
                s.put('\\');
6474
            }
6475
            flush();
6476
            return true;
6477
        }
6478
        return false;
6479
    }
6480

6481
    enum optionType
6482
    {
6483
        option_bool,
6484
        option_int
6485
    };
6486

6487
    // parses an int/bool option from the command line
6488
    bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type,
6489
                        int& res) {
6490
        String parsedValue;
6491
        if(!parseOption(argc, argv, pattern, &parsedValue))
6492
            return false;
6493

6494
        if(type) {
6495
            // integer
6496
            // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse...
6497
            int theInt = std::atoi(parsedValue.c_str());
6498
            if (theInt != 0) {
6499
                res = theInt; //!OCLINT parameter reassignment
6500
                return true;
6501
            }
6502
        } else {
6503
            // boolean
6504
            const char positive[][5] = { "1", "true", "on", "yes" };  // 5 - strlen("true") + 1
6505
            const char negative[][6] = { "0", "false", "off", "no" }; // 6 - strlen("false") + 1
6506

6507
            // if the value matches any of the positive/negative possibilities
6508
            for (unsigned i = 0; i < 4; i++) {
6509
                if (parsedValue.compare(positive[i], true) == 0) {
6510
                    res = 1; //!OCLINT parameter reassignment
6511
                    return true;
6512
                }
6513
                if (parsedValue.compare(negative[i], true) == 0) {
6514
                    res = 0; //!OCLINT parameter reassignment
6515
                    return true;
6516
                }
6517
            }
6518
        }
6519
        return false;
6520
    }
6521
} // namespace
6522

6523
Context::Context(int argc, const char* const* argv)
6524
        : p(new detail::ContextState) {
6525
    parseArgs(argc, argv, true);
6526
    if(argc)
6527
        p->binary_name = argv[0];
6528
}
6529

6530
Context::~Context() {
6531
    if(g_cs == p)
6532
        g_cs = nullptr;
6533
    delete p;
6534
}
6535

6536
void Context::applyCommandLine(int argc, const char* const* argv) {
6537
    parseArgs(argc, argv);
6538
    if(argc)
6539
        p->binary_name = argv[0];
6540
}
6541

6542
// parses args
6543
void Context::parseArgs(int argc, const char* const* argv, bool withDefaults) {
6544
    using namespace detail;
6545

6546
    // clang-format off
6547
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file=",        p->filters[0]);
6548
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sf=",                 p->filters[0]);
6549
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "source-file-exclude=",p->filters[1]);
6550
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sfe=",                p->filters[1]);
6551
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite=",         p->filters[2]);
6552
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ts=",                 p->filters[2]);
6553
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-suite-exclude=", p->filters[3]);
6554
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tse=",                p->filters[3]);
6555
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case=",          p->filters[4]);
6556
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tc=",                 p->filters[4]);
6557
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-case-exclude=",  p->filters[5]);
6558
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tce=",                p->filters[5]);
6559
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase=",            p->filters[6]);
6560
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sc=",                 p->filters[6]);
6561
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "subcase-exclude=",    p->filters[7]);
6562
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "sce=",                p->filters[7]);
6563
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "reporters=",          p->filters[8]);
6564
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "r=",                  p->filters[8]);
6565
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "test-path=",          p->filters[9]);
6566
    parseCommaSepArgs(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "tp=",                 p->filters[9]);
6567
    // clang-format on
6568

6569
    int    intRes = 0;
6570
    String strRes;
6571

6572
#define DOCTEST_PARSE_AS_BOOL_OR_FLAG(name, sname, var, default)                                   \
6573
    if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_bool, intRes) ||  \
6574
       parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_bool, intRes))   \
6575
        p->var = static_cast<bool>(intRes);                                                        \
6576
    else if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name) ||                           \
6577
            parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname))                            \
6578
        p->var = true;                                                                             \
6579
    else if(withDefaults)                                                                          \
6580
    p->var = default
6581

6582
#define DOCTEST_PARSE_INT_OPTION(name, sname, var, default)                                        \
6583
    if(parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", option_int, intRes) ||   \
6584
       parseIntOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", option_int, intRes))    \
6585
        p->var = intRes;                                                                           \
6586
    else if(withDefaults)                                                                          \
6587
    p->var = default
6588

6589
#define DOCTEST_PARSE_STR_OPTION(name, sname, var, default)                                        \
6590
    if(parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX name "=", &strRes, default) ||        \
6591
       parseOption(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX sname "=", &strRes, default) ||       \
6592
       withDefaults)                                                                               \
6593
    p->var = strRes
6594

6595
    // clang-format off
6596
    DOCTEST_PARSE_STR_OPTION("out", "o", out, "");
6597
    DOCTEST_PARSE_STR_OPTION("order-by", "ob", order_by, "file");
6598
    DOCTEST_PARSE_INT_OPTION("rand-seed", "rs", rand_seed, 0);
6599

6600
    DOCTEST_PARSE_INT_OPTION("first", "f", first, 0);
6601
    DOCTEST_PARSE_INT_OPTION("last", "l", last, UINT_MAX);
6602

6603
    DOCTEST_PARSE_INT_OPTION("abort-after", "aa", abort_after, 0);
6604
    DOCTEST_PARSE_INT_OPTION("subcase-filter-levels", "scfl", subcase_filter_levels, INT_MAX);
6605

6606
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("success", "s", success, false);
6607
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("case-sensitive", "cs", case_sensitive, false);
6608
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("exit", "e", exit, false);
6609
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("duration", "d", duration, false);
6610
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("minimal", "m", minimal, false);
6611
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("quiet", "q", quiet, false);
6612
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-throw", "nt", no_throw, false);
6613
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-exitcode", "ne", no_exitcode, false);
6614
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-run", "nr", no_run, false);
6615
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-intro", "ni", no_intro, false);
6616
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-version", "nv", no_version, false);
6617
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-colors", "nc", no_colors, false);
6618
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("force-colors", "fc", force_colors, false);
6619
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-breaks", "nb", no_breaks, false);
6620
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skip", "ns", no_skip, false);
6621
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("gnu-file-line", "gfl", gnu_file_line, !bool(DOCTEST_MSVC));
6622
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-path-filenames", "npf", no_path_in_filenames, false);
6623
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-line-numbers", "nln", no_line_numbers, false);
6624
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-debug-output", "ndo", no_debug_output, false);
6625
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-skipped-summary", "nss", no_skipped_summary, false);
6626
    DOCTEST_PARSE_AS_BOOL_OR_FLAG("no-time-in-output", "ntio", no_time_in_output, false);
6627
    // clang-format on
6628

6629
    if(withDefaults) {
6630
        p->help             = false;
6631
        p->version          = false;
6632
        p->count            = false;
6633
        p->list_test_cases  = false;
6634
        p->list_test_suites = false;
6635
        p->list_reporters   = false;
6636
    }
6637
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "help") ||
6638
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "h") ||
6639
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "?")) {
6640
        p->help = true;
6641
        p->exit = true;
6642
    }
6643
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "version") ||
6644
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "v")) {
6645
        p->version = true;
6646
        p->exit    = true;
6647
    }
6648
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "count") ||
6649
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "c")) {
6650
        p->count = true;
6651
        p->exit  = true;
6652
    }
6653
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-cases") ||
6654
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "ltc")) {
6655
        p->list_test_cases = true;
6656
        p->exit            = true;
6657
    }
6658
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-test-suites") ||
6659
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lts")) {
6660
        p->list_test_suites = true;
6661
        p->exit             = true;
6662
    }
6663
    if(parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "list-reporters") ||
6664
       parseFlag(argc, argv, DOCTEST_CONFIG_OPTIONS_PREFIX "lr")) {
6665
        p->list_reporters = true;
6666
        p->exit           = true;
6667
    }
6668
}
6669

6670
// allows the user to add procedurally to the filters from the command line
6671
void Context::addFilter(const char* filter, const char* value) { setOption(filter, value); }
6672

6673
// allows the user to clear all filters from the command line
6674
void Context::clearFilters() {
6675
    for(auto& curr : p->filters)
6676
        curr.clear();
6677
}
6678

6679
// allows the user to override procedurally the bool options from the command line
6680
void Context::setOption(const char* option, bool value) {
6681
    setOption(option, value ? "true" : "false");
6682
}
6683

6684
// allows the user to override procedurally the int options from the command line
6685
void Context::setOption(const char* option, int value) {
6686
    setOption(option, toString(value).c_str());
6687
}
6688

6689
// allows the user to override procedurally the string options from the command line
6690
void Context::setOption(const char* option, const char* value) {
6691
    auto argv   = String("-") + option + "=" + value;
6692
    auto lvalue = argv.c_str();
6693
    parseArgs(1, &lvalue);
6694
}
6695

6696
// users should query this in their main() and exit the program if true
6697
bool Context::shouldExit() { return p->exit; }
6698

6699
void Context::setAsDefaultForAssertsOutOfTestCases() { g_cs = p; }
6700

6701
void Context::setAssertHandler(detail::assert_handler ah) { p->ah = ah; }
6702

6703
void Context::setCout(std::ostream* out) { p->cout = out; }
6704

6705
static class DiscardOStream : public std::ostream
6706
{
6707
private:
6708
    class : public std::streambuf
6709
    {
6710
    private:
6711
        // allowing some buffering decreases the amount of calls to overflow
6712
        char buf[1024];
6713

6714
    protected:
6715
        std::streamsize xsputn(const char_type*, std::streamsize count) override { return count; }
6716

6717
        int_type overflow(int_type ch) override {
6718
            setp(std::begin(buf), std::end(buf));
6719
            return traits_type::not_eof(ch);
6720
        }
6721
    } discardBuf;
6722

6723
public:
6724
    DiscardOStream()
6725
            : std::ostream(&discardBuf) {}
6726
} discardOut;
6727

6728
// the main function that does all the filtering and test running
6729
int Context::run() {
6730
    using namespace detail;
6731

6732
    // save the old context state in case such was setup - for using asserts out of a testing context
6733
    auto old_cs = g_cs;
6734
    // this is the current contest
6735
    g_cs               = p;
6736
    is_running_in_test = true;
6737

6738
    g_no_colors = p->no_colors;
6739
    p->resetRunData();
6740

6741
    std::fstream fstr;
6742
    if(p->cout == nullptr) {
6743
        if(p->quiet) {
6744
            p->cout = &discardOut;
6745
        } else if(p->out.size()) {
6746
            // to a file if specified
6747
            fstr.open(p->out.c_str(), std::fstream::out);
6748
            p->cout = &fstr;
6749
        } else {
6750
            // stdout by default
6751
            p->cout = &std::cout;
6752
        }
6753
    }
6754

6755
    FatalConditionHandler::allocateAltStackMem();
6756

6757
    auto cleanup_and_return = [&]() {
6758
        FatalConditionHandler::freeAltStackMem();
6759

6760
        if(fstr.is_open())
6761
            fstr.close();
6762

6763
        // restore context
6764
        g_cs               = old_cs;
6765
        is_running_in_test = false;
6766

6767
        // we have to free the reporters which were allocated when the run started
6768
        for(auto& curr : p->reporters_currently_used)
6769
            delete curr;
6770
        p->reporters_currently_used.clear();
6771

6772
        if(p->numTestCasesFailed && !p->no_exitcode)
6773
            return EXIT_FAILURE;
6774
        return EXIT_SUCCESS;
6775
    };
6776

6777
    // setup default reporter if none is given through the command line
6778
    if(p->filters[8].empty())
6779
        p->filters[8].push_back("console");
6780

6781
    // check to see if any of the registered reporters has been selected
6782
    for(auto& curr : getReporters()) {
6783
        if(matchesAny(curr.first.second.c_str(), p->filters[8], false, p->case_sensitive))
6784
            p->reporters_currently_used.push_back(curr.second(*g_cs));
6785
    }
6786

6787
    // TODO: check if there is nothing in reporters_currently_used
6788

6789
    // prepend all listeners
6790
    for(auto& curr : getListeners())
6791
        p->reporters_currently_used.insert(p->reporters_currently_used.begin(), curr.second(*g_cs));
6792

6793
#ifdef DOCTEST_PLATFORM_WINDOWS
6794
    if(isDebuggerActive() && p->no_debug_output == false)
6795
        p->reporters_currently_used.push_back(new DebugOutputWindowReporter(*g_cs));
6796
#endif // DOCTEST_PLATFORM_WINDOWS
6797

6798
    // handle version, help and no_run
6799
    if(p->no_run || p->version || p->help || p->list_reporters) {
6800
        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, QueryData());
6801

6802
        return cleanup_and_return();
6803
    }
6804

6805
    std::vector<const TestCase*> testArray;
6806
    for(auto& curr : getRegisteredTests())
6807
        testArray.push_back(&curr);
6808
    p->numTestCases = testArray.size();
6809

6810
    // sort the collected records
6811
    if(!testArray.empty()) {
6812
        if(p->order_by.compare("file", true) == 0) {
6813
            std::sort(testArray.begin(), testArray.end(), fileOrderComparator);
6814
        } else if(p->order_by.compare("suite", true) == 0) {
6815
            std::sort(testArray.begin(), testArray.end(), suiteOrderComparator);
6816
        } else if(p->order_by.compare("name", true) == 0) {
6817
            std::sort(testArray.begin(), testArray.end(), nameOrderComparator);
6818
        } else if(p->order_by.compare("rand", true) == 0) {
6819
            std::srand(p->rand_seed);
6820

6821
            // random_shuffle implementation
6822
            const auto first = &testArray[0];
6823
            for(size_t i = testArray.size() - 1; i > 0; --i) {
6824
                int idxToSwap = std::rand() % (i + 1);
6825

6826
                const auto temp = first[i];
6827

6828
                first[i]         = first[idxToSwap];
6829
                first[idxToSwap] = temp;
6830
            }
6831
        } else if(p->order_by.compare("none", true) == 0) {
6832
            // means no sorting - beneficial for death tests which call into the executable
6833
            // with a specific test case in mind - we don't want to slow down the startup times
6834
        }
6835
    }
6836

6837
    std::set<String> testSuitesPassingFilt;
6838

6839
    bool                             query_mode = p->count || p->list_test_cases || p->list_test_suites;
6840
    std::vector<const TestCaseData*> queryResults;
6841

6842
    if(!query_mode)
6843
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_start, DOCTEST_EMPTY);
6844

6845
    // invoke the registered functions if they match the filter criteria (or just count them)
6846
    for(auto& curr : testArray) {
6847
        const auto& tc = *curr;
6848

6849
        bool skip_me = false;
6850
        if(tc.m_skip && !p->no_skip)
6851
            skip_me = true;
6852

6853
        if(!matchesAny(tc.m_file.c_str(), p->filters[0], true, p->case_sensitive))
6854
            skip_me = true;
6855
        if(matchesAny(tc.m_file.c_str(), p->filters[1], false, p->case_sensitive))
6856
            skip_me = true;
6857
        if(!matchesAny(tc.m_test_suite, p->filters[2], true, p->case_sensitive))
6858
            skip_me = true;
6859
        if(matchesAny(tc.m_test_suite, p->filters[3], false, p->case_sensitive))
6860
            skip_me = true;
6861
        if(!matchesAny(tc.m_name, p->filters[4], true, p->case_sensitive))
6862
            skip_me = true;
6863
        if(matchesAny(tc.m_name, p->filters[5], false, p->case_sensitive))
6864
            skip_me = true;
6865
        if(!matchesAny((String(tc.m_test_suite) + "/" + String(tc.m_name)).c_str(), p->filters[9], true, p->case_sensitive))
6866
            skip_me = true;
6867

6868
        if(!skip_me)
6869
            p->numTestCasesPassingFilters++;
6870

6871
        // skip the test if it is not in the execution range
6872
        if((p->last < p->numTestCasesPassingFilters && p->first <= p->last) ||
6873
           (p->first > p->numTestCasesPassingFilters))
6874
            skip_me = true;
6875

6876
        if(skip_me) {
6877
            if(!query_mode)
6878
                DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_skipped, tc);
6879
            continue;
6880
        }
6881

6882
        // do not execute the test if we are to only count the number of filter passing tests
6883
        if(p->count)
6884
            continue;
6885

6886
        // print the name of the test and don't execute it
6887
        if(p->list_test_cases) {
6888
            queryResults.push_back(&tc);
6889
            continue;
6890
        }
6891

6892
        // print the name of the test suite if not done already and don't execute it
6893
        if(p->list_test_suites) {
6894
            if((testSuitesPassingFilt.count(tc.m_test_suite) == 0) && tc.m_test_suite[0] != '\0') {
6895
                queryResults.push_back(&tc);
6896
                testSuitesPassingFilt.insert(tc.m_test_suite);
6897
                p->numTestSuitesPassingFilters++;
6898
            }
6899
            continue;
6900
        }
6901

6902
        // execute the test if it passes all the filtering
6903
        {
6904
            p->currentTest = &tc;
6905

6906
            p->failure_flags = TestCaseFailureReason::None;
6907
            p->seconds       = 0;
6908

6909
            // reset atomic counters
6910
            p->numAssertsFailedCurrentTest_atomic = 0;
6911
            p->numAssertsCurrentTest_atomic       = 0;
6912

6913
            p->fullyTraversedSubcases.clear();
6914

6915
            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_start, tc);
6916

6917
            p->timer.start();
6918

6919
            bool run_test = true;
6920

6921
            do {
6922
                // reset some of the fields for subcases (except for the set of fully passed ones)
6923
                p->reachedLeaf = false;
6924
                // May not be empty if previous subcase exited via exception.
6925
                p->subcaseStack.clear();
6926
                p->currentSubcaseDepth = 0;
6927

6928
                p->shouldLogCurrentException = true;
6929

6930
                // reset stuff for logging with INFO()
6931
                p->stringifiedContexts.clear();
6932

6933
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
6934
                try {
6935
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
6936
// MSVC 2015 diagnoses fatalConditionHandler as unused (because reset() is a static method)
6937
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4101) // unreferenced local variable
6938
                    FatalConditionHandler fatalConditionHandler; // Handle signals
6939
                    // execute the test
6940
                    tc.m_test();
6941
                    fatalConditionHandler.reset();
6942
DOCTEST_MSVC_SUPPRESS_WARNING_POP
6943
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
6944
                } catch(const TestFailureException&) {
6945
                    p->failure_flags |= TestCaseFailureReason::AssertFailure;
6946
                } catch(...) {
6947
                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception,
6948
                                                      {translateActiveException(), false});
6949
                    p->failure_flags |= TestCaseFailureReason::Exception;
6950
                }
6951
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
6952

6953
                // exit this loop if enough assertions have failed - even if there are more subcases
6954
                if(p->abort_after > 0 &&
6955
                   p->numAssertsFailed + p->numAssertsFailedCurrentTest_atomic >= p->abort_after) {
6956
                    run_test = false;
6957
                    p->failure_flags |= TestCaseFailureReason::TooManyFailedAsserts;
6958
                }
6959

6960
                if(!p->nextSubcaseStack.empty() && run_test)
6961
                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_reenter, tc);
6962
                if(p->nextSubcaseStack.empty())
6963
                    run_test = false;
6964
            } while(run_test);
6965

6966
            p->finalizeTestCaseData();
6967

6968
            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);
6969

6970
            p->currentTest = nullptr;
6971

6972
            // stop executing tests if enough assertions have failed
6973
            if(p->abort_after > 0 && p->numAssertsFailed >= p->abort_after)
6974
                break;
6975
        }
6976
    }
6977

6978
    if(!query_mode) {
6979
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
6980
    } else {
6981
        QueryData qdata;
6982
        qdata.run_stats = g_cs;
6983
        qdata.data      = queryResults.data();
6984
        qdata.num_data  = unsigned(queryResults.size());
6985
        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, qdata);
6986
    }
6987

6988
    return cleanup_and_return();
6989
}
6990

6991
DOCTEST_DEFINE_INTERFACE(IReporter)
6992

6993
int IReporter::get_num_active_contexts() { return detail::g_infoContexts.size(); }
6994
const IContextScope* const* IReporter::get_active_contexts() {
6995
    return get_num_active_contexts() ? &detail::g_infoContexts[0] : nullptr;
6996
}
6997

6998
int IReporter::get_num_stringified_contexts() { return detail::g_cs->stringifiedContexts.size(); }
6999
const String* IReporter::get_stringified_contexts() {
7000
    return get_num_stringified_contexts() ? &detail::g_cs->stringifiedContexts[0] : nullptr;
7001
}
7002

7003
namespace detail {
7004
    void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
7005
        if(isReporter)
7006
            getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
7007
        else
7008
            getListeners().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
7009
    }
7010
} // namespace detail
7011

7012
} // namespace doctest
7013

7014
#endif // DOCTEST_CONFIG_DISABLE
7015

7016
#ifdef DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
7017
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4007) // 'function' : must be 'attribute' - see issue #182
7018
int main(int argc, char** argv) { return doctest::Context(argc, argv).run(); }
7019
DOCTEST_MSVC_SUPPRESS_WARNING_POP
7020
#endif // DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
7021

7022
DOCTEST_CLANG_SUPPRESS_WARNING_POP
7023
DOCTEST_MSVC_SUPPRESS_WARNING_POP
7024
DOCTEST_GCC_SUPPRESS_WARNING_POP
7025

7026
DOCTEST_SUPPRESS_COMMON_WARNINGS_POP
7027

7028
#endif // DOCTEST_LIBRARY_IMPLEMENTATION
7029
#endif // DOCTEST_CONFIG_IMPLEMENT
7030

7031
Product

Resources

Company
