projects / awesomized / libmemcached / blob
? search:
summary | shortlog | log | commit | commitdiff | tree | github
history | raw | HEAD
Merge pull request #140 from hussainnaqvee/patch-1
[awesomized/libmemcached] / test / lib / catch.hpp
1 /*
2 * Catch v2.13.6
3 * Generated: 2021-04-16 18:23:38.044268
4 * ----------------------------------------------------------
5 * This file has been merged from multiple headers. Please don't edit it directly
6 * Copyright (c) 2021 Two Blue Cubes Ltd. All rights reserved.
7 *
8 * Distributed under the Boost Software License, Version 1.0. (See accompanying
9 * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
10 */
11 #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
12 #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
13 // start catch.hpp
14
15
16 #define CATCH_VERSION_MAJOR 2
17 #define CATCH_VERSION_MINOR 13
18 #define CATCH_VERSION_PATCH 6
19
20 #ifdef __clang__
21 # pragma clang system_header
22 #elif defined __GNUC__
23 # pragma GCC system_header
24 #endif
25
26 // start catch_suppress_warnings.h
27
28 #ifdef __clang__
29 # ifdef __ICC // icpc defines the __clang__ macro
30 # pragma warning(push)
31 # pragma warning(disable: 161 1682)
32 # else // __ICC
33 # pragma clang diagnostic push
34 # pragma clang diagnostic ignored "-Wpadded"
35 # pragma clang diagnostic ignored "-Wswitch-enum"
36 # pragma clang diagnostic ignored "-Wcovered-switch-default"
37 # endif
38 #elif defined __GNUC__
39 // Because REQUIREs trigger GCC's -Wparentheses, and because still
40 // supported version of g++ have only buggy support for _Pragmas,
41 // Wparentheses have to be suppressed globally.
42 # pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
43
44 # pragma GCC diagnostic push
45 # pragma GCC diagnostic ignored "-Wunused-variable"
46 # pragma GCC diagnostic ignored "-Wpadded"
47 #endif
48 // end catch_suppress_warnings.h
49 #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
50 # define CATCH_IMPL
51 # define CATCH_CONFIG_ALL_PARTS
52 #endif
53
54 // In the impl file, we want to have access to all parts of the headers
55 // Can also be used to sanely support PCHs
56 #if defined(CATCH_CONFIG_ALL_PARTS)
57 # define CATCH_CONFIG_EXTERNAL_INTERFACES
58 # if defined(CATCH_CONFIG_DISABLE_MATCHERS)
59 # undef CATCH_CONFIG_DISABLE_MATCHERS
60 # endif
61 # if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
62 # define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
63 # endif
64 #endif
65
66 #if !defined(CATCH_CONFIG_IMPL_ONLY)
67 // start catch_platform.h
68
69 // See e.g.:
70 // https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
71 #ifdef __APPLE__
72 # include <TargetConditionals.h>
73 # if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
74 (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
75 # define CATCH_PLATFORM_MAC
76 # elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
77 # define CATCH_PLATFORM_IPHONE
78 # endif
79
80 #elif defined(linux) || defined(__linux) || defined(__linux__)
81 # define CATCH_PLATFORM_LINUX
82
83 #elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
84 # define CATCH_PLATFORM_WINDOWS
85 #endif
86
87 // end catch_platform.h
88
89 #ifdef CATCH_IMPL
90 # ifndef CLARA_CONFIG_MAIN
91 # define CLARA_CONFIG_MAIN_NOT_DEFINED
92 # define CLARA_CONFIG_MAIN
93 # endif
94 #endif
95
96 // start catch_user_interfaces.h
97
98 namespace Catch {
99 unsigned int rngSeed();
100 }
101
102 // end catch_user_interfaces.h
103 // start catch_tag_alias_autoregistrar.h
104
105 // start catch_common.h
106
107 // start catch_compiler_capabilities.h
108
109 // Detect a number of compiler features - by compiler
110 // The following features are defined:
111 //
112 // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
113 // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
114 // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
115 // CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
116 // ****************
117 // Note to maintainers: if new toggles are added please document them
118 // in configuration.md, too
119 // ****************
120
121 // In general each macro has a _NO_<feature name> form
122 // (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
123 // Many features, at point of detection, define an _INTERNAL_ macro, so they
124 // can be combined, en-mass, with the _NO_ forms later.
125
126 #ifdef __cplusplus
127
128 # if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
129 # define CATCH_CPP14_OR_GREATER
130 # endif
131
132 # if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
133 # define CATCH_CPP17_OR_GREATER
134 # endif
135
136 #endif
137
138 // Only GCC compiler should be used in this block, so other compilers trying to
139 // mask themselves as GCC should be ignored.
140 #if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)
141 # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
142 # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" )
143
144 # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
145
146 #endif
147
148 #if defined(__clang__)
149
150 # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
151 # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" )
152
153 // As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
154 // which results in calls to destructors being emitted for each temporary,
155 // without a matching initialization. In practice, this can result in something
156 // like `std::string::~string` being called on an uninitialized value.
157 //
158 // For example, this code will likely segfault under IBM XL:
159 // ```
160 // REQUIRE(std::string("12") + "34" == "1234")
161 // ```
162 //
163 // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
164 # if !defined(__ibmxl__) && !defined(__CUDACC__)
165 # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
166 # endif
167
168 # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
169 _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
170 _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
171
172 # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
173 _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
174
175 # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
176 _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
177
178 # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
179 _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
180
181 # define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
182 _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
183
184 #endif // __clang__
185
186 ////////////////////////////////////////////////////////////////////////////////
187 // Assume that non-Windows platforms support posix signals by default
188 #if !defined(CATCH_PLATFORM_WINDOWS)
189 #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
190 #endif
191
192 ////////////////////////////////////////////////////////////////////////////////
193 // We know some environments not to support full POSIX signals
194 #if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
195 #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
196 #endif
197
198 #ifdef __OS400__
199 # define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
200 # define CATCH_CONFIG_COLOUR_NONE
201 #endif
202
203 ////////////////////////////////////////////////////////////////////////////////
204 // Android somehow still does not support std::to_string
205 #if defined(__ANDROID__)
206 # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
207 # define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
208 #endif
209
210 ////////////////////////////////////////////////////////////////////////////////
211 // Not all Windows environments support SEH properly
212 #if defined(__MINGW32__)
213 # define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
214 #endif
215
216 ////////////////////////////////////////////////////////////////////////////////
217 // PS4
218 #if defined(__ORBIS__)
219 # define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
220 #endif
221
222 ////////////////////////////////////////////////////////////////////////////////
223 // Cygwin
224 #ifdef __CYGWIN__
225
226 // Required for some versions of Cygwin to declare gettimeofday
227 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
228 # define _BSD_SOURCE
229 // some versions of cygwin (most) do not support std::to_string. Use the libstd check.
230 // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
231 # if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
232 && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
233
234 # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
235
236 # endif
237 #endif // __CYGWIN__
238
239 ////////////////////////////////////////////////////////////////////////////////
240 // Visual C++
241 #if defined(_MSC_VER)
242
243 # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
244 # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) )
245
246 // Universal Windows platform does not support SEH
247 // Or console colours (or console at all...)
248 # if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
249 # define CATCH_CONFIG_COLOUR_NONE
250 # else
251 # define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
252 # endif
253
254 // MSVC traditional preprocessor needs some workaround for __VA_ARGS__
255 // _MSVC_TRADITIONAL == 0 means new conformant preprocessor
256 // _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
257 # if !defined(__clang__) // Handle Clang masquerading for msvc
258 # if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
259 # define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
260 # endif // MSVC_TRADITIONAL
261 # endif // __clang__
262
263 #endif // _MSC_VER
264
265 #if defined(_REENTRANT) || defined(_MSC_VER)
266 // Enable async processing, as -pthread is specified or no additional linking is required
267 # define CATCH_INTERNAL_CONFIG_USE_ASYNC
268 #endif // _MSC_VER
269
270 ////////////////////////////////////////////////////////////////////////////////
271 // Check if we are compiled with -fno-exceptions or equivalent
272 #if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
273 # define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
274 #endif
275
276 ////////////////////////////////////////////////////////////////////////////////
277 // DJGPP
278 #ifdef __DJGPP__
279 # define CATCH_INTERNAL_CONFIG_NO_WCHAR
280 #endif // __DJGPP__
281
282 ////////////////////////////////////////////////////////////////////////////////
283 // Embarcadero C++Build
284 #if defined(__BORLANDC__)
285 #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
286 #endif
287
288 ////////////////////////////////////////////////////////////////////////////////
289
290 // Use of __COUNTER__ is suppressed during code analysis in
291 // CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
292 // handled by it.
293 // Otherwise all supported compilers support COUNTER macro,
294 // but user still might want to turn it off
295 #if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
296 #define CATCH_INTERNAL_CONFIG_COUNTER
297 #endif
298
299 ////////////////////////////////////////////////////////////////////////////////
300
301 // RTX is a special version of Windows that is real time.
302 // This means that it is detected as Windows, but does not provide
303 // the same set of capabilities as real Windows does.
304 #if defined(UNDER_RTSS) || defined(RTX64_BUILD)
305 #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
306 #define CATCH_INTERNAL_CONFIG_NO_ASYNC
307 #define CATCH_CONFIG_COLOUR_NONE
308 #endif
309
310 #if !defined(_GLIBCXX_USE_C99_MATH_TR1)
311 #define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
312 #endif
313
314 // Various stdlib support checks that require __has_include
315 #if defined(__has_include)
316 // Check if string_view is available and usable
317 #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
318 # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
319 #endif
320
321 // Check if optional is available and usable
322 # if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
323 # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
324 # endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
325
326 // Check if byte is available and usable
327 # if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
328 # include <cstddef>
329 # if __cpp_lib_byte > 0
330 # define CATCH_INTERNAL_CONFIG_CPP17_BYTE
331 # endif
332 # endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
333
334 // Check if variant is available and usable
335 # if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
336 # if defined(__clang__) && (__clang_major__ < 8)
337 // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
338 // fix should be in clang 8, workaround in libstdc++ 8.2
339 # include <ciso646>
340 # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
341 # define CATCH_CONFIG_NO_CPP17_VARIANT
342 # else
343 # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
344 # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
345 # else
346 # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
347 # endif // defined(__clang__) && (__clang_major__ < 8)
348 # endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
349 #endif // defined(__has_include)
350
351 #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
352 # define CATCH_CONFIG_COUNTER
353 #endif
354 #if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
355 # define CATCH_CONFIG_WINDOWS_SEH
356 #endif
357 // This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
358 #if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
359 # define CATCH_CONFIG_POSIX_SIGNALS
360 #endif
361 // This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
362 #if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
363 # define CATCH_CONFIG_WCHAR
364 #endif
365
366 #if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
367 # define CATCH_CONFIG_CPP11_TO_STRING
368 #endif
369
370 #if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
371 # define CATCH_CONFIG_CPP17_OPTIONAL
372 #endif
373
374 #if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
375 # define CATCH_CONFIG_CPP17_STRING_VIEW
376 #endif
377
378 #if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
379 # define CATCH_CONFIG_CPP17_VARIANT
380 #endif
381
382 #if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
383 # define CATCH_CONFIG_CPP17_BYTE
384 #endif
385
386 #if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
387 # define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
388 #endif
389
390 #if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
391 # define CATCH_CONFIG_NEW_CAPTURE
392 #endif
393
394 #if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
395 # define CATCH_CONFIG_DISABLE_EXCEPTIONS
396 #endif
397
398 #if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
399 # define CATCH_CONFIG_POLYFILL_ISNAN
400 #endif
401
402 #if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
403 # define CATCH_CONFIG_USE_ASYNC
404 #endif
405
406 #if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
407 # define CATCH_CONFIG_ANDROID_LOGWRITE
408 #endif
409
410 #if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
411 # define CATCH_CONFIG_GLOBAL_NEXTAFTER
412 #endif
413
414 // Even if we do not think the compiler has that warning, we still have
415 // to provide a macro that can be used by the code.
416 #if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
417 # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
418 #endif
419 #if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
420 # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
421 #endif
422 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
423 # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
424 #endif
425 #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
426 # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
427 #endif
428 #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
429 # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
430 #endif
431 #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
432 # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
433 #endif
434
435 // The goal of this macro is to avoid evaluation of the arguments, but
436 // still have the compiler warn on problems inside...
437 #if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
438 # define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
439 #endif
440
441 #if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
442 # undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
443 #elif defined(__clang__) && (__clang_major__ < 5)
444 # undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
445 #endif
446
447 #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
448 # define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
449 #endif
450
451 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
452 #define CATCH_TRY if ((true))
453 #define CATCH_CATCH_ALL if ((false))
454 #define CATCH_CATCH_ANON(type) if ((false))
455 #else
456 #define CATCH_TRY try
457 #define CATCH_CATCH_ALL catch (...)
458 #define CATCH_CATCH_ANON(type) catch (type)
459 #endif
460
461 #if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
462 #define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
463 #endif
464
465 // end catch_compiler_capabilities.h
466 #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
467 #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
468 #ifdef CATCH_CONFIG_COUNTER
469 # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
470 #else
471 # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
472 #endif
473
474 #include <iosfwd>
475 #include <string>
476 #include <cstdint>
477
478 // We need a dummy global operator<< so we can bring it into Catch namespace later
479 struct Catch_global_namespace_dummy {};
480 std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
481
482 namespace Catch {
483
484 struct CaseSensitive { enum Choice {
485 Yes,
486 No
487 }; };
488
489 class NonCopyable {
490 NonCopyable( NonCopyable const& ) = delete;
491 NonCopyable( NonCopyable && ) = delete;
492 NonCopyable& operator = ( NonCopyable const& ) = delete;
493 NonCopyable& operator = ( NonCopyable && ) = delete;
494
495 protected:
496 NonCopyable();
497 virtual ~NonCopyable();
498 };
499
500 struct SourceLineInfo {
501
502 SourceLineInfo() = delete;
503 SourceLineInfo( char const* _file, std::size_t _line ) noexcept
504 : file( _file ),
505 line( _line )
506 {}
507
508 SourceLineInfo( SourceLineInfo const& other ) = default;
509 SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
510 SourceLineInfo( SourceLineInfo&& ) noexcept = default;
511 SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
512
513 bool empty() const noexcept { return file[0] == '\0'; }
514 bool operator == ( SourceLineInfo const& other ) const noexcept;
515 bool operator < ( SourceLineInfo const& other ) const noexcept;
516
517 char const* file;
518 std::size_t line;
519 };
520
521 std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
522
523 // Bring in operator<< from global namespace into Catch namespace
524 // This is necessary because the overload of operator<< above makes
525 // lookup stop at namespace Catch
526 using ::operator<<;
527
528 // Use this in variadic streaming macros to allow
529 // >> +StreamEndStop
530 // as well as
531 // >> stuff +StreamEndStop
532 struct StreamEndStop {
533 std::string operator+() const;
534 };
535 template<typename T>
536 T const& operator + ( T const& value, StreamEndStop ) {
537 return value;
538 }
539 }
540
541 #define CATCH_INTERNAL_LINEINFO \
542 ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
543
544 // end catch_common.h
545 namespace Catch {
546
547 struct RegistrarForTagAliases {
548 RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
549 };
550
551 } // end namespace Catch
552
553 #define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
554 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
555 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
556 namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
557 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
558
559 // end catch_tag_alias_autoregistrar.h
560 // start catch_test_registry.h
561
562 // start catch_interfaces_testcase.h
563
564 #include <vector>
565
566 namespace Catch {
567
568 class TestSpec;
569
570 struct ITestInvoker {
571 virtual void invoke () const = 0;
572 virtual ~ITestInvoker();
573 };
574
575 class TestCase;
576 struct IConfig;
577
578 struct ITestCaseRegistry {
579 virtual ~ITestCaseRegistry();
580 virtual std::vector<TestCase> const& getAllTests() const = 0;
581 virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
582 };
583
584 bool isThrowSafe( TestCase const& testCase, IConfig const& config );
585 bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
586 std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
587 std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
588
589 }
590
591 // end catch_interfaces_testcase.h
592 // start catch_stringref.h
593
594 #include <cstddef>
595 #include <string>
596 #include <iosfwd>
597 #include <cassert>
598
599 namespace Catch {
600
601 /// A non-owning string class (similar to the forthcoming std::string_view)
602 /// Note that, because a StringRef may be a substring of another string,
603 /// it may not be null terminated.
604 class StringRef {
605 public:
606 using size_type = std::size_t;
607 using const_iterator = const char*;
608
609 private:
610 static constexpr char const* const s_empty = "";
611
612 char const* m_start = s_empty;
613 size_type m_size = 0;
614
615 public: // construction
616 constexpr StringRef() noexcept = default;
617
618 StringRef( char const* rawChars ) noexcept;
619
620 constexpr StringRef( char const* rawChars, size_type size ) noexcept
621 : m_start( rawChars ),
622 m_size( size )
623 {}
624
625 StringRef( std::string const& stdString ) noexcept
626 : m_start( stdString.c_str() ),
627 m_size( stdString.size() )
628 {}
629
630 explicit operator std::string() const {
631 return std::string(m_start, m_size);
632 }
633
634 public: // operators
635 auto operator == ( StringRef const& other ) const noexcept -> bool;
636 auto operator != (StringRef const& other) const noexcept -> bool {
637 return !(*this == other);
638 }
639
640 auto operator[] ( size_type index ) const noexcept -> char {
641 assert(index < m_size);
642 return m_start[index];
643 }
644
645 public: // named queries
646 constexpr auto empty() const noexcept -> bool {
647 return m_size == 0;
648 }
649 constexpr auto size() const noexcept -> size_type {
650 return m_size;
651 }
652
653 // Returns the current start pointer. If the StringRef is not
654 // null-terminated, throws std::domain_exception
655 auto c_str() const -> char const*;
656
657 public: // substrings and searches
658 // Returns a substring of [start, start + length).
659 // If start + length > size(), then the substring is [start, size()).
660 // If start > size(), then the substring is empty.
661 auto substr( size_type start, size_type length ) const noexcept -> StringRef;
662
663 // Returns the current start pointer. May not be null-terminated.
664 auto data() const noexcept -> char const*;
665
666 constexpr auto isNullTerminated() const noexcept -> bool {
667 return m_start[m_size] == '\0';
668 }
669
670 public: // iterators
671 constexpr const_iterator begin() const { return m_start; }
672 constexpr const_iterator end() const { return m_start + m_size; }
673 };
674
675 auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
676 auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
677
678 constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
679 return StringRef( rawChars, size );
680 }
681 } // namespace Catch
682
683 constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
684 return Catch::StringRef( rawChars, size );
685 }
686
687 // end catch_stringref.h
688 // start catch_preprocessor.hpp
689
690
691 #define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
692 #define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
693 #define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
694 #define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
695 #define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
696 #define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
697
698 #ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
699 #define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
700 // MSVC needs more evaluations
701 #define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
702 #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
703 #else
704 #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)
705 #endif
706
707 #define CATCH_REC_END(...)
708 #define CATCH_REC_OUT
709
710 #define CATCH_EMPTY()
711 #define CATCH_DEFER(id) id CATCH_EMPTY()
712
713 #define CATCH_REC_GET_END2() 0, CATCH_REC_END
714 #define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
715 #define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
716 #define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
717 #define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
718 #define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
719
720 #define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
721 #define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
722 #define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
723
724 #define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
725 #define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
726 #define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
727
728 // Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
729 // and passes userdata as the first parameter to each invocation,
730 // e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
731 #define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
732
733 #define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
734
735 #define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
736 #define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
737 #define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
738 #define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
739 #define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
740 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
741 #define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
742 #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
743 #else
744 // MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
745 #define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
746 #define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
747 #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
748 #endif
749
750 #define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
751 #define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
752
753 #define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
754
755 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
756 #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
757 #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
758 #else
759 #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
760 #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
761 #endif
762
763 #define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
764 CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
765
766 #define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
767 #define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
768 #define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
769 #define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
770 #define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
771 #define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
772 #define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
773 #define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
774 #define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
775 #define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
776 #define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
777
778 #define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
779
780 #define INTERNAL_CATCH_TYPE_GEN\
781 template<typename...> struct TypeList {};\
782 template<typename...Ts>\
783 constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
784 template<template<typename...> class...> struct TemplateTypeList{};\
785 template<template<typename...> class...Cs>\
786 constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
787 template<typename...>\
788 struct append;\
789 template<typename...>\
790 struct rewrap;\
791 template<template<typename...> class, typename...>\
792 struct create;\
793 template<template<typename...> class, typename>\
794 struct convert;\
795 \
796 template<typename T> \
797 struct append<T> { using type = T; };\
798 template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
799 struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
800 template< template<typename...> class L1, typename...E1, typename...Rest>\
801 struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
802 \
803 template< template<typename...> class Container, template<typename...> class List, typename...elems>\
804 struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
805 template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
806 struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
807 \
808 template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
809 struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
810 template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
811 struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
812
813 #define INTERNAL_CATCH_NTTP_1(signature, ...)\
814 template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
815 template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
816 constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
817 template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
818 template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
819 constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
820 \
821 template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
822 struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
823 template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
824 struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
825 template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
826 struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
827
828 #define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
829 #define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
830 template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
831 static void TestName()
832 #define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
833 template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
834 static void TestName()
835
836 #define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
837 #define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
838 template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
839 static void TestName()
840 #define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
841 template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
842 static void TestName()
843
844 #define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
845 template<typename Type>\
846 void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
847 {\
848 Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
849 }
850
851 #define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
852 template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
853 void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
854 {\
855 Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
856 }
857
858 #define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
859 template<typename Type>\
860 void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
861 {\
862 Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
863 }
864
865 #define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
866 template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
867 void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
868 {\
869 Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
870 }
871
872 #define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
873 #define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
874 template<typename TestType> \
875 struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
876 void test();\
877 }
878
879 #define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
880 template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
881 struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
882 void test();\
883 }
884
885 #define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
886 #define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
887 template<typename TestType> \
888 void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
889 #define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
890 template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
891 void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
892
893 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
894 #define INTERNAL_CATCH_NTTP_0
895 #define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
896 #define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
897 #define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
898 #define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
899 #define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
900 #define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
901 #define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
902 #define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
903 #else
904 #define INTERNAL_CATCH_NTTP_0(signature)
905 #define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
906 #define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
907 #define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
908 #define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
909 #define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
910 #define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
911 #define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
912 #define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
913 #endif
914
915 // end catch_preprocessor.hpp
916 // start catch_meta.hpp
917
918
919 #include <type_traits>
920
921 namespace Catch {
922 template<typename T>
923 struct always_false : std::false_type {};
924
925 template <typename> struct true_given : std::true_type {};
926 struct is_callable_tester {
927 template <typename Fun, typename... Args>
928 true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
929 template <typename...>
930 std::false_type static test(...);
931 };
932
933 template <typename T>
934 struct is_callable;
935
936 template <typename Fun, typename... Args>
937 struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
938
939 #if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
940 // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
941 // replaced with std::invoke_result here.
942 template <typename Func, typename... U>
943 using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
944 #else
945 // Keep ::type here because we still support C++11
946 template <typename Func, typename... U>
947 using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U...)>::type>::type>::type;
948 #endif
949
950 } // namespace Catch
951
952 namespace mpl_{
953 struct na;
954 }
955
956 // end catch_meta.hpp
957 namespace Catch {
958
959 template<typename C>
960 class TestInvokerAsMethod : public ITestInvoker {
961 void (C::*m_testAsMethod)();
962 public:
963 TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
964
965 void invoke() const override {
966 C obj;
967 (obj.*m_testAsMethod)();
968 }
969 };
970
971 auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
972
973 template<typename C>
974 auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
975 return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
976 }
977
978 struct NameAndTags {
979 NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
980 StringRef name;
981 StringRef tags;
982 };
983
984 struct AutoReg : NonCopyable {
985 AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
986 ~AutoReg();
987 };
988
989 } // end namespace Catch
990
991 #if defined(CATCH_CONFIG_DISABLE)
992 #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
993 static void TestName()
994 #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
995 namespace{ \
996 struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
997 void test(); \
998 }; \
999 } \
1000 void TestName::test()
1001 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... ) \
1002 INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
1003 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
1004 namespace{ \
1005 namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
1006 INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
1007 } \
1008 } \
1009 INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
1010
1011 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1012 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
1013 INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
1014 #else
1015 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
1016 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
1017 #endif
1018
1019 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1020 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
1021 INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
1022 #else
1023 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
1024 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
1025 #endif
1026
1027 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1028 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
1029 INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
1030 #else
1031 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
1032 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
1033 #endif
1034
1035 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1036 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
1037 INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
1038 #else
1039 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
1040 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
1041 #endif
1042 #endif
1043
1044 ///////////////////////////////////////////////////////////////////////////////
1045 #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
1046 static void TestName(); \
1047 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1048 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1049 namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
1050 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1051 static void TestName()
1052 #define INTERNAL_CATCH_TESTCASE( ... ) \
1053 INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
1054
1055 ///////////////////////////////////////////////////////////////////////////////
1056 #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
1057 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1058 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1059 namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
1060 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
1061
1062 ///////////////////////////////////////////////////////////////////////////////
1063 #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
1064 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1065 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1066 namespace{ \
1067 struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
1068 void test(); \
1069 }; \
1070 Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
1071 } \
1072 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1073 void TestName::test()
1074 #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
1075 INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
1076
1077 ///////////////////////////////////////////////////////////////////////////////
1078 #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
1079 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1080 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1081 Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
1082 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
1083
1084 ///////////////////////////////////////////////////////////////////////////////
1085 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
1086 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1087 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1088 CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
1089 CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
1090 INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
1091 namespace {\
1092 namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
1093 INTERNAL_CATCH_TYPE_GEN\
1094 INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
1095 INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
1096 template<typename...Types> \
1097 struct TestName{\
1098 TestName(){\
1099 int index = 0; \
1100 constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
1101 using expander = int[];\
1102 (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
1103 }\
1104 };\
1105 static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
1106 TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
1107 return 0;\
1108 }();\
1109 }\
1110 }\
1111 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1112 INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
1113
1114 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1115 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
1116 INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
1117 #else
1118 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
1119 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
1120 #endif
1121
1122 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1123 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
1124 INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
1125 #else
1126 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
1127 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
1128 #endif
1129
1130 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
1131 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1132 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1133 CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
1134 CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
1135 template<typename TestType> static void TestFuncName(); \
1136 namespace {\
1137 namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
1138 INTERNAL_CATCH_TYPE_GEN \
1139 INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
1140 template<typename... Types> \
1141 struct TestName { \
1142 void reg_tests() { \
1143 int index = 0; \
1144 using expander = int[]; \
1145 constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
1146 constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
1147 constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
1148 (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */\
1149 } \
1150 }; \
1151 static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
1152 using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
1153 TestInit t; \
1154 t.reg_tests(); \
1155 return 0; \
1156 }(); \
1157 } \
1158 } \
1159 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1160 template<typename TestType> \
1161 static void TestFuncName()
1162
1163 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1164 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
1165 INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
1166 #else
1167 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
1168 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
1169 #endif
1170
1171 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1172 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
1173 INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
1174 #else
1175 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
1176 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
1177 #endif
1178
1179 #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
1180 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1181 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1182 CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
1183 template<typename TestType> static void TestFunc(); \
1184 namespace {\
1185 namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
1186 INTERNAL_CATCH_TYPE_GEN\
1187 template<typename... Types> \
1188 struct TestName { \
1189 void reg_tests() { \
1190 int index = 0; \
1191 using expander = int[]; \
1192 (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
1193 } \
1194 };\
1195 static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
1196 using TestInit = typename convert<TestName, TmplList>::type; \
1197 TestInit t; \
1198 t.reg_tests(); \
1199 return 0; \
1200 }(); \
1201 }}\
1202 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1203 template<typename TestType> \
1204 static void TestFunc()
1205
1206 #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
1207 INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
1208
1209 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
1210 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1211 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1212 CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
1213 CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
1214 namespace {\
1215 namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
1216 INTERNAL_CATCH_TYPE_GEN\
1217 INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
1218 INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
1219 INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
1220 template<typename...Types> \
1221 struct TestNameClass{\
1222 TestNameClass(){\
1223 int index = 0; \
1224 constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
1225 using expander = int[];\
1226 (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
1227 }\
1228 };\
1229 static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
1230 TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
1231 return 0;\
1232 }();\
1233 }\
1234 }\
1235 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1236 INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
1237
1238 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1239 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
1240 INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
1241 #else
1242 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
1243 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
1244 #endif
1245
1246 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1247 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
1248 INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
1249 #else
1250 #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
1251 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
1252 #endif
1253
1254 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
1255 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1256 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1257 CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
1258 CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
1259 template<typename TestType> \
1260 struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
1261 void test();\
1262 };\
1263 namespace {\
1264 namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
1265 INTERNAL_CATCH_TYPE_GEN \
1266 INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
1267 template<typename...Types>\
1268 struct TestNameClass{\
1269 void reg_tests(){\
1270 int index = 0;\
1271 using expander = int[];\
1272 constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
1273 constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
1274 constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
1275 (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */ \
1276 }\
1277 };\
1278 static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
1279 using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
1280 TestInit t;\
1281 t.reg_tests();\
1282 return 0;\
1283 }(); \
1284 }\
1285 }\
1286 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1287 template<typename TestType> \
1288 void TestName<TestType>::test()
1289
1290 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1291 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
1292 INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
1293 #else
1294 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
1295 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
1296 #endif
1297
1298 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
1299 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
1300 INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
1301 #else
1302 #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
1303 INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
1304 #endif
1305
1306 #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
1307 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
1308 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
1309 CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
1310 template<typename TestType> \
1311 struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
1312 void test();\
1313 };\
1314 namespace {\
1315 namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
1316 INTERNAL_CATCH_TYPE_GEN\
1317 template<typename...Types>\
1318 struct TestNameClass{\
1319 void reg_tests(){\
1320 int index = 0;\
1321 using expander = int[];\
1322 (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
1323 }\
1324 };\
1325 static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
1326 using TestInit = typename convert<TestNameClass, TmplList>::type;\
1327 TestInit t;\
1328 t.reg_tests();\
1329 return 0;\
1330 }(); \
1331 }}\
1332 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
1333 template<typename TestType> \
1334 void TestName<TestType>::test()
1335
1336 #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
1337 INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
1338
1339 // end catch_test_registry.h
1340 // start catch_capture.hpp
1341
1342 // start catch_assertionhandler.h
1343
1344 // start catch_assertioninfo.h
1345
1346 // start catch_result_type.h
1347
1348 namespace Catch {
1349
1350 // ResultWas::OfType enum
1351 struct ResultWas { enum OfType {
1352 Unknown = -1,
1353 Ok = 0,
1354 Info = 1,
1355 Warning = 2,
1356
1357 FailureBit = 0x10,
1358
1359 ExpressionFailed = FailureBit | 1,
1360 ExplicitFailure = FailureBit | 2,
1361
1362 Exception = 0x100 | FailureBit,
1363
1364 ThrewException = Exception | 1,
1365 DidntThrowException = Exception | 2,
1366
1367 FatalErrorCondition = 0x200 | FailureBit
1368
1369 }; };
1370
1371 bool isOk( ResultWas::OfType resultType );
1372 bool isJustInfo( int flags );
1373
1374 // ResultDisposition::Flags enum
1375 struct ResultDisposition { enum Flags {
1376 Normal = 0x01,
1377
1378 ContinueOnFailure = 0x02, // Failures fail test, but execution continues
1379 FalseTest = 0x04, // Prefix expression with !
1380 SuppressFail = 0x08 // Failures are reported but do not fail the test
1381 }; };
1382
1383 ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
1384
1385 bool shouldContinueOnFailure( int flags );
1386 inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
1387 bool shouldSuppressFailure( int flags );
1388
1389 } // end namespace Catch
1390
1391 // end catch_result_type.h
1392 namespace Catch {
1393
1394 struct AssertionInfo
1395 {
1396 StringRef macroName;
1397 SourceLineInfo lineInfo;
1398 StringRef capturedExpression;
1399 ResultDisposition::Flags resultDisposition;
1400
1401 // We want to delete this constructor but a compiler bug in 4.8 means
1402 // the struct is then treated as non-aggregate
1403 //AssertionInfo() = delete;
1404 };
1405
1406 } // end namespace Catch
1407
1408 // end catch_assertioninfo.h
1409 // start catch_decomposer.h
1410
1411 // start catch_tostring.h
1412
1413 #include <vector>
1414 #include <cstddef>
1415 #include <type_traits>
1416 #include <string>
1417 // start catch_stream.h
1418
1419 #include <iosfwd>
1420 #include <cstddef>
1421 #include <ostream>
1422
1423 namespace Catch {
1424
1425 std::ostream& cout();
1426 std::ostream& cerr();
1427 std::ostream& clog();
1428
1429 class StringRef;
1430
1431 struct IStream {
1432 virtual ~IStream();
1433 virtual std::ostream& stream() const = 0;
1434 };
1435
1436 auto makeStream( StringRef const &filename ) -> IStream const*;
1437
1438 class ReusableStringStream : NonCopyable {
1439 std::size_t m_index;
1440 std::ostream* m_oss;
1441 public:
1442 ReusableStringStream();
1443 ~ReusableStringStream();
1444
1445 auto str() const -> std::string;
1446
1447 template<typename T>
1448 auto operator << ( T const& value ) -> ReusableStringStream& {
1449 *m_oss << value;
1450 return *this;
1451 }
1452 auto get() -> std::ostream& { return *m_oss; }
1453 };
1454 }
1455
1456 // end catch_stream.h
1457 // start catch_interfaces_enum_values_registry.h
1458
1459 #include <vector>
1460
1461 namespace Catch {
1462
1463 namespace Detail {
1464 struct EnumInfo {
1465 StringRef m_name;
1466 std::vector<std::pair<int, StringRef>> m_values;
1467
1468 ~EnumInfo();
1469
1470 StringRef lookup( int value ) const;
1471 };
1472 } // namespace Detail
1473
1474 struct IMutableEnumValuesRegistry {
1475 virtual ~IMutableEnumValuesRegistry();
1476
1477 virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
1478
1479 template<typename E>
1480 Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
1481 static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
1482 std::vector<int> intValues;
1483 intValues.reserve( values.size() );
1484 for( auto enumValue : values )
1485 intValues.push_back( static_cast<int>( enumValue ) );
1486 return registerEnum( enumName, allEnums, intValues );
1487 }
1488 };
1489
1490 } // Catch
1491
1492 // end catch_interfaces_enum_values_registry.h
1493
1494 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
1495 #include <string_view>
1496 #endif
1497
1498 #ifdef __OBJC__
1499 // start catch_objc_arc.hpp
1500
1501 #import <Foundation/Foundation.h>
1502
1503 #ifdef __has_feature
1504 #define CATCH_ARC_ENABLED __has_feature(objc_arc)
1505 #else
1506 #define CATCH_ARC_ENABLED 0
1507 #endif
1508
1509 void arcSafeRelease( NSObject* obj );
1510 id performOptionalSelector( id obj, SEL sel );
1511
1512 #if !CATCH_ARC_ENABLED
1513 inline void arcSafeRelease( NSObject* obj ) {
1514 [obj release];
1515 }
1516 inline id performOptionalSelector( id obj, SEL sel ) {
1517 if( [obj respondsToSelector: sel] )
1518 return [obj performSelector: sel];
1519 return nil;
1520 }
1521 #define CATCH_UNSAFE_UNRETAINED
1522 #define CATCH_ARC_STRONG
1523 #else
1524 inline void arcSafeRelease( NSObject* ){}
1525 inline id performOptionalSelector( id obj, SEL sel ) {
1526 #ifdef __clang__
1527 #pragma clang diagnostic push
1528 #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
1529 #endif
1530 if( [obj respondsToSelector: sel] )
1531 return [obj performSelector: sel];
1532 #ifdef __clang__
1533 #pragma clang diagnostic pop
1534 #endif
1535 return nil;
1536 }
1537 #define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
1538 #define CATCH_ARC_STRONG __strong
1539 #endif
1540
1541 // end catch_objc_arc.hpp
1542 #endif
1543
1544 #ifdef _MSC_VER
1545 #pragma warning(push)
1546 #pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
1547 #endif
1548
1549 namespace Catch {
1550 namespace Detail {
1551
1552 extern const std::string unprintableString;
1553
1554 std::string rawMemoryToString( const void *object, std::size_t size );
1555
1556 template<typename T>
1557 std::string rawMemoryToString( const T& object ) {
1558 return rawMemoryToString( &object, sizeof(object) );
1559 }
1560
1561 template<typename T>
1562 class IsStreamInsertable {
1563 template<typename Stream, typename U>
1564 static auto test(int)
1565 -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
1566
1567 template<typename, typename>
1568 static auto test(...)->std::false_type;
1569
1570 public:
1571 static const bool value = decltype(test<std::ostream, const T&>(0))::value;
1572 };
1573
1574 template<typename E>
1575 std::string convertUnknownEnumToString( E e );
1576
1577 template<typename T>
1578 typename std::enable_if<
1579 !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
1580 std::string>::type convertUnstreamable( T const& ) {
1581 return Detail::unprintableString;
1582 }
1583 template<typename T>
1584 typename std::enable_if<
1585 !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
1586 std::string>::type convertUnstreamable(T const& ex) {
1587 return ex.what();
1588 }
1589
1590 template<typename T>
1591 typename std::enable_if<
1592 std::is_enum<T>::value
1593 , std::string>::type convertUnstreamable( T const& value ) {
1594 return convertUnknownEnumToString( value );
1595 }
1596
1597 #if defined(_MANAGED)
1598 //! Convert a CLR string to a utf8 std::string
1599 template<typename T>
1600 std::string clrReferenceToString( T^ ref ) {
1601 if (ref == nullptr)
1602 return std::string("null");
1603 auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
1604 cli::pin_ptr<System::Byte> p = &bytes[0];
1605 return std::string(reinterpret_cast<char const *>(p), bytes->Length);
1606 }
1607 #endif
1608
1609 } // namespace Detail
1610
1611 // If we decide for C++14, change these to enable_if_ts
1612 template <typename T, typename = void>
1613 struct StringMaker {
1614 template <typename Fake = T>
1615 static
1616 typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
1617 convert(const Fake& value) {
1618 ReusableStringStream rss;
1619 // NB: call using the function-like syntax to avoid ambiguity with
1620 // user-defined templated operator<< under clang.
1621 rss.operator<<(value);
1622 return rss.str();
1623 }
1624
1625 template <typename Fake = T>
1626 static
1627 typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
1628 convert( const Fake& value ) {
1629 #if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
1630 return Detail::convertUnstreamable(value);
1631 #else
1632 return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
1633 #endif
1634 }
1635 };
1636
1637 namespace Detail {
1638
1639 // This function dispatches all stringification requests inside of Catch.
1640 // Should be preferably called fully qualified, like ::Catch::Detail::stringify
1641 template <typename T>
1642 std::string stringify(const T& e) {
1643 return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
1644 }
1645
1646 template<typename E>
1647 std::string convertUnknownEnumToString( E e ) {
1648 return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
1649 }
1650
1651 #if defined(_MANAGED)
1652 template <typename T>
1653 std::string stringify( T^ e ) {
1654 return ::Catch::StringMaker<T^>::convert(e);
1655 }
1656 #endif
1657
1658 } // namespace Detail
1659
1660 // Some predefined specializations
1661
1662 template<>
1663 struct StringMaker<std::string> {
1664 static std::string convert(const std::string& str);
1665 };
1666
1667 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
1668 template<>
1669 struct StringMaker<std::string_view> {
1670 static std::string convert(std::string_view str);
1671 };
1672 #endif
1673
1674 template<>
1675 struct StringMaker<char const *> {
1676 static std::string convert(char const * str);
1677 };
1678 template<>
1679 struct StringMaker<char *> {
1680 static std::string convert(char * str);
1681 };
1682
1683 #ifdef CATCH_CONFIG_WCHAR
1684 template<>
1685 struct StringMaker<std::wstring> {
1686 static std::string convert(const std::wstring& wstr);
1687 };
1688
1689 # ifdef CATCH_CONFIG_CPP17_STRING_VIEW
1690 template<>
1691 struct StringMaker<std::wstring_view> {
1692 static std::string convert(std::wstring_view str);
1693 };
1694 # endif
1695
1696 template<>
1697 struct StringMaker<wchar_t const *> {
1698 static std::string convert(wchar_t const * str);
1699 };
1700 template<>
1701 struct StringMaker<wchar_t *> {
1702 static std::string convert(wchar_t * str);
1703 };
1704 #endif
1705
1706 // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
1707 // while keeping string semantics?
1708 template<int SZ>
1709 struct StringMaker<char[SZ]> {
1710 static std::string convert(char const* str) {
1711 return ::Catch::Detail::stringify(std::string{ str });
1712 }
1713 };
1714 template<int SZ>
1715 struct StringMaker<signed char[SZ]> {
1716 static std::string convert(signed char const* str) {
1717 return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
1718 }
1719 };
1720 template<int SZ>
1721 struct StringMaker<unsigned char[SZ]> {
1722 static std::string convert(unsigned char const* str) {
1723 return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
1724 }
1725 };
1726
1727 #if defined(CATCH_CONFIG_CPP17_BYTE)
1728 template<>
1729 struct StringMaker<std::byte> {
1730 static std::string convert(std::byte value);
1731 };
1732 #endif // defined(CATCH_CONFIG_CPP17_BYTE)
1733 template<>
1734 struct StringMaker<int> {
1735 static std::string convert(int value);
1736 };
1737 template<>
1738 struct StringMaker<long> {
1739 static std::string convert(long value);
1740 };
1741 template<>
1742 struct StringMaker<long long> {
1743 static std::string convert(long long value);
1744 };
1745 template<>
1746 struct StringMaker<unsigned int> {
1747 static std::string convert(unsigned int value);
1748 };
1749 template<>
1750 struct StringMaker<unsigned long> {
1751 static std::string convert(unsigned long value);
1752 };
1753 template<>
1754 struct StringMaker<unsigned long long> {
1755 static std::string convert(unsigned long long value);
1756 };
1757
1758 template<>
1759 struct StringMaker<bool> {
1760 static std::string convert(bool b);
1761 };
1762
1763 template<>
1764 struct StringMaker<char> {
1765 static std::string convert(char c);
1766 };
1767 template<>
1768 struct StringMaker<signed char> {
1769 static std::string convert(signed char c);
1770 };
1771 template<>
1772 struct StringMaker<unsigned char> {
1773 static std::string convert(unsigned char c);
1774 };
1775
1776 template<>
1777 struct StringMaker<std::nullptr_t> {
1778 static std::string convert(std::nullptr_t);
1779 };
1780
1781 template<>
1782 struct StringMaker<float> {
1783 static std::string convert(float value);
1784 static int precision;
1785 };
1786
1787 template<>
1788 struct StringMaker<double> {
1789 static std::string convert(double value);
1790 static int precision;
1791 };
1792
1793 template <typename T>
1794 struct StringMaker<T*> {
1795 template <typename U>
1796 static std::string convert(U* p) {
1797 if (p) {
1798 return ::Catch::Detail::rawMemoryToString(p);
1799 } else {
1800 return "nullptr";
1801 }
1802 }
1803 };
1804
1805 template <typename R, typename C>
1806 struct StringMaker<R C::*> {
1807 static std::string convert(R C::* p) {
1808 if (p) {
1809 return ::Catch::Detail::rawMemoryToString(p);
1810 } else {
1811 return "nullptr";
1812 }
1813 }
1814 };
1815
1816 #if defined(_MANAGED)
1817 template <typename T>
1818 struct StringMaker<T^> {
1819 static std::string convert( T^ ref ) {
1820 return ::Catch::Detail::clrReferenceToString(ref);
1821 }
1822 };
1823 #endif
1824
1825 namespace Detail {
1826 template<typename InputIterator, typename Sentinel = InputIterator>
1827 std::string rangeToString(InputIterator first, Sentinel last) {
1828 ReusableStringStream rss;
1829 rss << "{ ";
1830 if (first != last) {
1831 rss << ::Catch::Detail::stringify(*first);
1832 for (++first; first != last; ++first)
1833 rss << ", " << ::Catch::Detail::stringify(*first);
1834 }
1835 rss << " }";
1836 return rss.str();
1837 }
1838 }
1839
1840 #ifdef __OBJC__
1841 template<>
1842 struct StringMaker<NSString*> {
1843 static std::string convert(NSString * nsstring) {
1844 if (!nsstring)
1845 return "nil";
1846 return std::string("@") + [nsstring UTF8String];
1847 }
1848 };
1849 template<>
1850 struct StringMaker<NSObject*> {
1851 static std::string convert(NSObject* nsObject) {
1852 return ::Catch::Detail::stringify([nsObject description]);
1853 }
1854
1855 };
1856 namespace Detail {
1857 inline std::string stringify( NSString* nsstring ) {
1858 return StringMaker<NSString*>::convert( nsstring );
1859 }
1860
1861 } // namespace Detail
1862 #endif // __OBJC__
1863
1864 } // namespace Catch
1865
1866 //////////////////////////////////////////////////////
1867 // Separate std-lib types stringification, so it can be selectively enabled
1868 // This means that we do not bring in
1869
1870 #if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
1871 # define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
1872 # define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
1873 # define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
1874 # define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
1875 # define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
1876 #endif
1877
1878 // Separate std::pair specialization
1879 #if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
1880 #include <utility>
1881 namespace Catch {
1882 template<typename T1, typename T2>
1883 struct StringMaker<std::pair<T1, T2> > {
1884 static std::string convert(const std::pair<T1, T2>& pair) {
1885 ReusableStringStream rss;
1886 rss << "{ "
1887 << ::Catch::Detail::stringify(pair.first)
1888 << ", "
1889 << ::Catch::Detail::stringify(pair.second)
1890 << " }";
1891 return rss.str();
1892 }
1893 };
1894 }
1895 #endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
1896
1897 #if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
1898 #include <optional>
1899 namespace Catch {
1900 template<typename T>
1901 struct StringMaker<std::optional<T> > {
1902 static std::string convert(const std::optional<T>& optional) {
1903 ReusableStringStream rss;
1904 if (optional.has_value()) {
1905 rss << ::Catch::Detail::stringify(*optional);
1906 } else {
1907 rss << "{ }";
1908 }
1909 return rss.str();
1910 }
1911 };
1912 }
1913 #endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
1914
1915 // Separate std::tuple specialization
1916 #if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
1917 #include <tuple>
1918 namespace Catch {
1919 namespace Detail {
1920 template<
1921 typename Tuple,
1922 std::size_t N = 0,
1923 bool = (N < std::tuple_size<Tuple>::value)
1924 >
1925 struct TupleElementPrinter {
1926 static void print(const Tuple& tuple, std::ostream& os) {
1927 os << (N ? ", " : " ")
1928 << ::Catch::Detail::stringify(std::get<N>(tuple));
1929 TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
1930 }
1931 };
1932
1933 template<
1934 typename Tuple,
1935 std::size_t N
1936 >
1937 struct TupleElementPrinter<Tuple, N, false> {
1938 static void print(const Tuple&, std::ostream&) {}
1939 };
1940
1941 }
1942
1943 template<typename ...Types>
1944 struct StringMaker<std::tuple<Types...>> {
1945 static std::string convert(const std::tuple<Types...>& tuple) {
1946 ReusableStringStream rss;
1947 rss << '{';
1948 Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
1949 rss << " }";
1950 return rss.str();
1951 }
1952 };
1953 }
1954 #endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
1955
1956 #if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
1957 #include <variant>
1958 namespace Catch {
1959 template<>
1960 struct StringMaker<std::monostate> {
1961 static std::string convert(const std::monostate&) {
1962 return "{ }";
1963 }
1964 };
1965
1966 template<typename... Elements>
1967 struct StringMaker<std::variant<Elements...>> {
1968 static std::string convert(const std::variant<Elements...>& variant) {
1969 if (variant.valueless_by_exception()) {
1970 return "{valueless variant}";
1971 } else {
1972 return std::visit(
1973 [](const auto& value) {
1974 return ::Catch::Detail::stringify(value);
1975 },
1976 variant
1977 );
1978 }
1979 }
1980 };
1981 }
1982 #endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
1983
1984 namespace Catch {
1985 // Import begin/ end from std here
1986 using std::begin;
1987 using std::end;
1988
1989 namespace detail {
1990 template <typename...>
1991 struct void_type {
1992 using type = void;
1993 };
1994
1995 template <typename T, typename = void>
1996 struct is_range_impl : std::false_type {
1997 };
1998
1999 template <typename T>
2000 struct is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> : std::true_type {
2001 };
2002 } // namespace detail
2003
2004 template <typename T>
2005 struct is_range : detail::is_range_impl<T> {
2006 };
2007
2008 #if defined(_MANAGED) // Managed types are never ranges
2009 template <typename T>
2010 struct is_range<T^> {
2011 static const bool value = false;
2012 };
2013 #endif
2014
2015 template<typename Range>
2016 std::string rangeToString( Range const& range ) {
2017 return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
2018 }
2019
2020 // Handle vector<bool> specially
2021 template<typename Allocator>
2022 std::string rangeToString( std::vector<bool, Allocator> const& v ) {
2023 ReusableStringStream rss;
2024 rss << "{ ";
2025 bool first = true;
2026 for( bool b : v ) {
2027 if( first )
2028 first = false;
2029 else
2030 rss << ", ";
2031 rss << ::Catch::Detail::stringify( b );
2032 }
2033 rss << " }";
2034 return rss.str();
2035 }
2036
2037 template<typename R>
2038 struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
2039 static std::string convert( R const& range ) {
2040 return rangeToString( range );
2041 }
2042 };
2043
2044 template <typename T, int SZ>
2045 struct StringMaker<T[SZ]> {
2046 static std::string convert(T const(&arr)[SZ]) {
2047 return rangeToString(arr);
2048 }
2049 };
2050
2051 } // namespace Catch
2052
2053 // Separate std::chrono::duration specialization
2054 #if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
2055 #include <ctime>
2056 #include <ratio>
2057 #include <chrono>
2058
2059 namespace Catch {
2060
2061 template <class Ratio>
2062 struct ratio_string {
2063 static std::string symbol();
2064 };
2065
2066 template <class Ratio>
2067 std::string ratio_string<Ratio>::symbol() {
2068 Catch::ReusableStringStream rss;
2069 rss << '[' << Ratio::num << '/'
2070 << Ratio::den << ']';
2071 return rss.str();
2072 }
2073 template <>
2074 struct ratio_string<std::atto> {
2075 static std::string symbol();
2076 };
2077 template <>
2078 struct ratio_string<std::femto> {
2079 static std::string symbol();
2080 };
2081 template <>
2082 struct ratio_string<std::pico> {
2083 static std::string symbol();
2084 };
2085 template <>
2086 struct ratio_string<std::nano> {
2087 static std::string symbol();
2088 };
2089 template <>
2090 struct ratio_string<std::micro> {
2091 static std::string symbol();
2092 };
2093 template <>
2094 struct ratio_string<std::milli> {
2095 static std::string symbol();
2096 };
2097
2098 ////////////
2099 // std::chrono::duration specializations
2100 template<typename Value, typename Ratio>
2101 struct StringMaker<std::chrono::duration<Value, Ratio>> {
2102 static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
2103 ReusableStringStream rss;
2104 rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
2105 return rss.str();
2106 }
2107 };
2108 template<typename Value>
2109 struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
2110 static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
2111 ReusableStringStream rss;
2112 rss << duration.count() << " s";
2113 return rss.str();
2114 }
2115 };
2116 template<typename Value>
2117 struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
2118 static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
2119 ReusableStringStream rss;
2120 rss << duration.count() << " m";
2121 return rss.str();
2122 }
2123 };
2124 template<typename Value>
2125 struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
2126 static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
2127 ReusableStringStream rss;
2128 rss << duration.count() << " h";
2129 return rss.str();
2130 }
2131 };
2132
2133 ////////////
2134 // std::chrono::time_point specialization
2135 // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
2136 template<typename Clock, typename Duration>
2137 struct StringMaker<std::chrono::time_point<Clock, Duration>> {
2138 static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
2139 return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
2140 }
2141 };
2142 // std::chrono::time_point<system_clock> specialization
2143 template<typename Duration>
2144 struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
2145 static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
2146 auto converted = std::chrono::system_clock::to_time_t(time_point);
2147
2148 #ifdef _MSC_VER
2149 std::tm timeInfo = {};
2150 gmtime_s(&timeInfo, &converted);
2151 #else
2152 std::tm* timeInfo = std::gmtime(&converted);
2153 #endif
2154
2155 auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
2156 char timeStamp[timeStampSize];
2157 const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
2158
2159 #ifdef _MSC_VER
2160 std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
2161 #else
2162 std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
2163 #endif
2164 return std::string(timeStamp);
2165 }
2166 };
2167 }
2168 #endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
2169
2170 #define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
2171 namespace Catch { \
2172 template<> struct StringMaker<enumName> { \
2173 static std::string convert( enumName value ) { \
2174 static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
2175 return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
2176 } \
2177 }; \
2178 }
2179
2180 #define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
2181
2182 #ifdef _MSC_VER
2183 #pragma warning(pop)
2184 #endif
2185
2186 // end catch_tostring.h
2187 #include <iosfwd>
2188
2189 #ifdef _MSC_VER
2190 #pragma warning(push)
2191 #pragma warning(disable:4389) // '==' : signed/unsigned mismatch
2192 #pragma warning(disable:4018) // more "signed/unsigned mismatch"
2193 #pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
2194 #pragma warning(disable:4180) // qualifier applied to function type has no meaning
2195 #pragma warning(disable:4800) // Forcing result to true or false
2196 #endif
2197
2198 namespace Catch {
2199
2200 struct ITransientExpression {
2201 auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
2202 auto getResult() const -> bool { return m_result; }
2203 virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
2204
2205 ITransientExpression( bool isBinaryExpression, bool result )
2206 : m_isBinaryExpression( isBinaryExpression ),
2207 m_result( result )
2208 {}
2209
2210 // We don't actually need a virtual destructor, but many static analysers
2211 // complain if it's not here :-(
2212 virtual ~ITransientExpression();
2213
2214 bool m_isBinaryExpression;
2215 bool m_result;
2216
2217 };
2218
2219 void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
2220
2221 template<typename LhsT, typename RhsT>
2222 class BinaryExpr : public ITransientExpression {
2223 LhsT m_lhs;
2224 StringRef m_op;
2225 RhsT m_rhs;
2226
2227 void streamReconstructedExpression( std::ostream &os ) const override {
2228 formatReconstructedExpression
2229 ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
2230 }
2231
2232 public:
2233 BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
2234 : ITransientExpression{ true, comparisonResult },
2235 m_lhs( lhs ),
2236 m_op( op ),
2237 m_rhs( rhs )
2238 {}
2239
2240 template<typename T>
2241 auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2242 static_assert(always_false<T>::value,
2243 "chained comparisons are not supported inside assertions, "
2244 "wrap the expression inside parentheses, or decompose it");
2245 }
2246
2247 template<typename T>
2248 auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2249 static_assert(always_false<T>::value,
2250 "chained comparisons are not supported inside assertions, "
2251 "wrap the expression inside parentheses, or decompose it");
2252 }
2253
2254 template<typename T>
2255 auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2256 static_assert(always_false<T>::value,
2257 "chained comparisons are not supported inside assertions, "
2258 "wrap the expression inside parentheses, or decompose it");
2259 }
2260
2261 template<typename T>
2262 auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2263 static_assert(always_false<T>::value,
2264 "chained comparisons are not supported inside assertions, "
2265 "wrap the expression inside parentheses, or decompose it");
2266 }
2267
2268 template<typename T>
2269 auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2270 static_assert(always_false<T>::value,
2271 "chained comparisons are not supported inside assertions, "
2272 "wrap the expression inside parentheses, or decompose it");
2273 }
2274
2275 template<typename T>
2276 auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2277 static_assert(always_false<T>::value,
2278 "chained comparisons are not supported inside assertions, "
2279 "wrap the expression inside parentheses, or decompose it");
2280 }
2281
2282 template<typename T>
2283 auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2284 static_assert(always_false<T>::value,
2285 "chained comparisons are not supported inside assertions, "
2286 "wrap the expression inside parentheses, or decompose it");
2287 }
2288
2289 template<typename T>
2290 auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
2291 static_assert(always_false<T>::value,
2292 "chained comparisons are not supported inside assertions, "
2293 "wrap the expression inside parentheses, or decompose it");
2294 }
2295 };
2296
2297 template<typename LhsT>
2298 class UnaryExpr : public ITransientExpression {
2299 LhsT m_lhs;
2300
2301 void streamReconstructedExpression( std::ostream &os ) const override {
2302 os << Catch::Detail::stringify( m_lhs );
2303 }
2304
2305 public:
2306 explicit UnaryExpr( LhsT lhs )
2307 : ITransientExpression{ false, static_cast<bool>(lhs) },
2308 m_lhs( lhs )
2309 {}
2310 };
2311
2312 // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
2313 template<typename LhsT, typename RhsT>
2314 auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
2315 template<typename T>
2316 auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
2317 template<typename T>
2318 auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
2319 template<typename T>
2320 auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
2321 template<typename T>
2322 auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
2323
2324 template<typename LhsT, typename RhsT>
2325 auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
2326 template<typename T>
2327 auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
2328 template<typename T>
2329 auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
2330 template<typename T>
2331 auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
2332 template<typename T>
2333 auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
2334
2335 template<typename LhsT>
2336 class ExprLhs {
2337 LhsT m_lhs;
2338 public:
2339 explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
2340
2341 template<typename RhsT>
2342 auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
2343 return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
2344 }
2345 auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
2346 return { m_lhs == rhs, m_lhs, "==", rhs };
2347 }
2348
2349 template<typename RhsT>
2350 auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
2351 return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
2352 }
2353 auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
2354 return { m_lhs != rhs, m_lhs, "!=", rhs };
2355 }
2356
2357 template<typename RhsT>
2358 auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
2359 return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
2360 }
2361 template<typename RhsT>
2362 auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
2363 return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
2364 }
2365 template<typename RhsT>
2366 auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
2367 return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
2368 }
2369 template<typename RhsT>
2370 auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
2371 return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
2372 }
2373 template <typename RhsT>
2374 auto operator | (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
2375 return { static_cast<bool>(m_lhs | rhs), m_lhs, "|", rhs };
2376 }
2377 template <typename RhsT>
2378 auto operator & (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
2379 return { static_cast<bool>(m_lhs & rhs), m_lhs, "&", rhs };
2380 }
2381 template <typename RhsT>
2382 auto operator ^ (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
2383 return { static_cast<bool>(m_lhs ^ rhs), m_lhs, "^", rhs };
2384 }
2385
2386 template<typename RhsT>
2387 auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
2388 static_assert(always_false<RhsT>::value,
2389 "operator&& is not supported inside assertions, "
2390 "wrap the expression inside parentheses, or decompose it");
2391 }
2392
2393 template<typename RhsT>
2394 auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
2395 static_assert(always_false<RhsT>::value,
2396 "operator|| is not supported inside assertions, "
2397 "wrap the expression inside parentheses, or decompose it");
2398 }
2399
2400 auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
2401 return UnaryExpr<LhsT>{ m_lhs };
2402 }
2403 };
2404
2405 void handleExpression( ITransientExpression const& expr );
2406
2407 template<typename T>
2408 void handleExpression( ExprLhs<T> const& expr ) {
2409 handleExpression( expr.makeUnaryExpr() );
2410 }
2411
2412 struct Decomposer {
2413 template<typename T>
2414 auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
2415 return ExprLhs<T const&>{ lhs };
2416 }
2417
2418 auto operator <=( bool value ) -> ExprLhs<bool> {
2419 return ExprLhs<bool>{ value };
2420 }
2421 };
2422
2423 } // end namespace Catch
2424
2425 #ifdef _MSC_VER
2426 #pragma warning(pop)
2427 #endif
2428
2429 // end catch_decomposer.h
2430 // start catch_interfaces_capture.h
2431
2432 #include <string>
2433 #include <chrono>
2434
2435 namespace Catch {
2436
2437 class AssertionResult;
2438 struct AssertionInfo;
2439 struct SectionInfo;
2440 struct SectionEndInfo;
2441 struct MessageInfo;
2442 struct MessageBuilder;
2443 struct Counts;
2444 struct AssertionReaction;
2445 struct SourceLineInfo;
2446
2447 struct ITransientExpression;
2448 struct IGeneratorTracker;
2449
2450 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
2451 struct BenchmarkInfo;
2452 template <typename Duration = std::chrono::duration<double, std::nano>>
2453 struct BenchmarkStats;
2454 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
2455
2456 struct IResultCapture {
2457
2458 virtual ~IResultCapture();
2459
2460 virtual bool sectionStarted( SectionInfo const& sectionInfo,
2461 Counts& assertions ) = 0;
2462 virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
2463 virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
2464
2465 virtual auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
2466
2467 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
2468 virtual void benchmarkPreparing( std::string const& name ) = 0;
2469 virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
2470 virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
2471 virtual void benchmarkFailed( std::string const& error ) = 0;
2472 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
2473
2474 virtual void pushScopedMessage( MessageInfo const& message ) = 0;
2475 virtual void popScopedMessage( MessageInfo const& message ) = 0;
2476
2477 virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
2478
2479 virtual void handleFatalErrorCondition( StringRef message ) = 0;
2480
2481 virtual void handleExpr
2482 ( AssertionInfo const& info,
2483 ITransientExpression const& expr,
2484 AssertionReaction& reaction ) = 0;
2485 virtual void handleMessage
2486 ( AssertionInfo const& info,
2487 ResultWas::OfType resultType,
2488 StringRef const& message,
2489 AssertionReaction& reaction ) = 0;
2490 virtual void handleUnexpectedExceptionNotThrown
2491 ( AssertionInfo const& info,
2492 AssertionReaction& reaction ) = 0;
2493 virtual void handleUnexpectedInflightException
2494 ( AssertionInfo const& info,
2495 std::string const& message,
2496 AssertionReaction& reaction ) = 0;
2497 virtual void handleIncomplete
2498 ( AssertionInfo const& info ) = 0;
2499 virtual void handleNonExpr
2500 ( AssertionInfo const &info,
2501 ResultWas::OfType resultType,
2502 AssertionReaction &reaction ) = 0;
2503
2504 virtual bool lastAssertionPassed() = 0;
2505 virtual void assertionPassed() = 0;
2506
2507 // Deprecated, do not use:
2508 virtual std::string getCurrentTestName() const = 0;
2509 virtual const AssertionResult* getLastResult() const = 0;
2510 virtual void exceptionEarlyReported() = 0;
2511 };
2512
2513 IResultCapture& getResultCapture();
2514 }
2515
2516 // end catch_interfaces_capture.h
2517 namespace Catch {
2518
2519 struct TestFailureException{};
2520 struct AssertionResultData;
2521 struct IResultCapture;
2522 class RunContext;
2523
2524 class LazyExpression {
2525 friend class AssertionHandler;
2526 friend struct AssertionStats;
2527 friend class RunContext;
2528
2529 ITransientExpression const* m_transientExpression = nullptr;
2530 bool m_isNegated;
2531 public:
2532 LazyExpression( bool isNegated );
2533 LazyExpression( LazyExpression const& other );
2534 LazyExpression& operator = ( LazyExpression const& ) = delete;
2535
2536 explicit operator bool() const;
2537
2538 friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
2539 };
2540
2541 struct AssertionReaction {
2542 bool shouldDebugBreak = false;
2543 bool shouldThrow = false;
2544 };
2545
2546 class AssertionHandler {
2547 AssertionInfo m_assertionInfo;
2548 AssertionReaction m_reaction;
2549 bool m_completed = false;
2550 IResultCapture& m_resultCapture;
2551
2552 public:
2553 AssertionHandler
2554 ( StringRef const& macroName,
2555 SourceLineInfo const& lineInfo,
2556 StringRef capturedExpression,
2557 ResultDisposition::Flags resultDisposition );
2558 ~AssertionHandler() {
2559 if ( !m_completed ) {
2560 m_resultCapture.handleIncomplete( m_assertionInfo );
2561 }
2562 }
2563
2564 template<typename T>
2565 void handleExpr( ExprLhs<T> const& expr ) {
2566 handleExpr( expr.makeUnaryExpr() );
2567 }
2568 void handleExpr( ITransientExpression const& expr );
2569
2570 void handleMessage(ResultWas::OfType resultType, StringRef const& message);
2571
2572 void handleExceptionThrownAsExpected();
2573 void handleUnexpectedExceptionNotThrown();
2574 void handleExceptionNotThrownAsExpected();
2575 void handleThrowingCallSkipped();
2576 void handleUnexpectedInflightException();
2577
2578 void complete();
2579 void setCompleted();
2580
2581 // query
2582 auto allowThrows() const -> bool;
2583 };
2584
2585 void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
2586
2587 } // namespace Catch
2588
2589 // end catch_assertionhandler.h
2590 // start catch_message.h
2591
2592 #include <string>
2593 #include <vector>
2594
2595 namespace Catch {
2596
2597 struct MessageInfo {
2598 MessageInfo( StringRef const& _macroName,
2599 SourceLineInfo const& _lineInfo,
2600 ResultWas::OfType _type );
2601
2602 StringRef macroName;
2603 std::string message;
2604 SourceLineInfo lineInfo;
2605 ResultWas::OfType type;
2606 unsigned int sequence;
2607
2608 bool operator == ( MessageInfo const& other ) const;
2609 bool operator < ( MessageInfo const& other ) const;
2610 private:
2611 static unsigned int globalCount;
2612 };
2613
2614 struct MessageStream {
2615
2616 template<typename T>
2617 MessageStream& operator << ( T const& value ) {
2618 m_stream << value;
2619 return *this;
2620 }
2621
2622 ReusableStringStream m_stream;
2623 };
2624
2625 struct MessageBuilder : MessageStream {
2626 MessageBuilder( StringRef const& macroName,
2627 SourceLineInfo const& lineInfo,
2628 ResultWas::OfType type );
2629
2630 template<typename T>
2631 MessageBuilder& operator << ( T const& value ) {
2632 m_stream << value;
2633 return *this;
2634 }
2635
2636 MessageInfo m_info;
2637 };
2638
2639 class ScopedMessage {
2640 public:
2641 explicit ScopedMessage( MessageBuilder const& builder );
2642 ScopedMessage( ScopedMessage& duplicate ) = delete;
2643 ScopedMessage( ScopedMessage&& old );
2644 ~ScopedMessage();
2645
2646 MessageInfo m_info;
2647 bool m_moved;
2648 };
2649
2650 class Capturer {
2651 std::vector<MessageInfo> m_messages;
2652 IResultCapture& m_resultCapture = getResultCapture();
2653 size_t m_captured = 0;
2654 public:
2655 Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
2656 ~Capturer();
2657
2658 void captureValue( size_t index, std::string const& value );
2659
2660 template<typename T>
2661 void captureValues( size_t index, T const& value ) {
2662 captureValue( index, Catch::Detail::stringify( value ) );
2663 }
2664
2665 template<typename T, typename... Ts>
2666 void captureValues( size_t index, T const& value, Ts const&... values ) {
2667 captureValue( index, Catch::Detail::stringify(value) );
2668 captureValues( index+1, values... );
2669 }
2670 };
2671
2672 } // end namespace Catch
2673
2674 // end catch_message.h
2675 #if !defined(CATCH_CONFIG_DISABLE)
2676
2677 #if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
2678 #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
2679 #else
2680 #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
2681 #endif
2682
2683 #if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
2684
2685 ///////////////////////////////////////////////////////////////////////////////
2686 // Another way to speed-up compilation is to omit local try-catch for REQUIRE*
2687 // macros.
2688 #define INTERNAL_CATCH_TRY
2689 #define INTERNAL_CATCH_CATCH( capturer )
2690
2691 #else // CATCH_CONFIG_FAST_COMPILE
2692
2693 #define INTERNAL_CATCH_TRY try
2694 #define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
2695
2696 #endif
2697
2698 #define INTERNAL_CATCH_REACT( handler ) handler.complete();
2699
2700 ///////////////////////////////////////////////////////////////////////////////
2701 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
2702 do { \
2703 CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
2704 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
2705 INTERNAL_CATCH_TRY { \
2706 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
2707 CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
2708 catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
2709 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
2710 } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
2711 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
2712 } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
2713
2714 ///////////////////////////////////////////////////////////////////////////////
2715 #define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
2716 INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
2717 if( Catch::getResultCapture().lastAssertionPassed() )
2718
2719 ///////////////////////////////////////////////////////////////////////////////
2720 #define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
2721 INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
2722 if( !Catch::getResultCapture().lastAssertionPassed() )
2723
2724 ///////////////////////////////////////////////////////////////////////////////
2725 #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
2726 do { \
2727 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
2728 try { \
2729 static_cast<void>(__VA_ARGS__); \
2730 catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
2731 } \
2732 catch( ... ) { \
2733 catchAssertionHandler.handleUnexpectedInflightException(); \
2734 } \
2735 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
2736 } while( false )
2737
2738 ///////////////////////////////////////////////////////////////////////////////
2739 #define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
2740 do { \
2741 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
2742 if( catchAssertionHandler.allowThrows() ) \
2743 try { \
2744 static_cast<void>(__VA_ARGS__); \
2745 catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
2746 } \
2747 catch( ... ) { \
2748 catchAssertionHandler.handleExceptionThrownAsExpected(); \
2749 } \
2750 else \
2751 catchAssertionHandler.handleThrowingCallSkipped(); \
2752 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
2753 } while( false )
2754
2755 ///////////////////////////////////////////////////////////////////////////////
2756 #define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
2757 do { \
2758 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
2759 if( catchAssertionHandler.allowThrows() ) \
2760 try { \
2761 static_cast<void>(expr); \
2762 catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
2763 } \
2764 catch( exceptionType const& ) { \
2765 catchAssertionHandler.handleExceptionThrownAsExpected(); \
2766 } \
2767 catch( ... ) { \
2768 catchAssertionHandler.handleUnexpectedInflightException(); \
2769 } \
2770 else \
2771 catchAssertionHandler.handleThrowingCallSkipped(); \
2772 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
2773 } while( false )
2774
2775 ///////////////////////////////////////////////////////////////////////////////
2776 #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
2777 do { \
2778 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
2779 catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
2780 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
2781 } while( false )
2782
2783 ///////////////////////////////////////////////////////////////////////////////
2784 #define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
2785 auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
2786 varName.captureValues( 0, __VA_ARGS__ )
2787
2788 ///////////////////////////////////////////////////////////////////////////////
2789 #define INTERNAL_CATCH_INFO( macroName, log ) \
2790 Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
2791
2792 ///////////////////////////////////////////////////////////////////////////////
2793 #define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
2794 Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
2795
2796 ///////////////////////////////////////////////////////////////////////////////
2797 // Although this is matcher-based, it can be used with just a string
2798 #define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
2799 do { \
2800 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
2801 if( catchAssertionHandler.allowThrows() ) \
2802 try { \
2803 static_cast<void>(__VA_ARGS__); \
2804 catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
2805 } \
2806 catch( ... ) { \
2807 Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
2808 } \
2809 else \
2810 catchAssertionHandler.handleThrowingCallSkipped(); \
2811 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
2812 } while( false )
2813
2814 #endif // CATCH_CONFIG_DISABLE
2815
2816 // end catch_capture.hpp
2817 // start catch_section.h
2818
2819 // start catch_section_info.h
2820
2821 // start catch_totals.h
2822
2823 #include <cstddef>
2824
2825 namespace Catch {
2826
2827 struct Counts {
2828 Counts operator - ( Counts const& other ) const;
2829 Counts& operator += ( Counts const& other );
2830
2831 std::size_t total() const;
2832 bool allPassed() const;
2833 bool allOk() const;
2834
2835 std::size_t passed = 0;
2836 std::size_t failed = 0;
2837 std::size_t failedButOk = 0;
2838 };
2839
2840 struct Totals {
2841
2842 Totals operator - ( Totals const& other ) const;
2843 Totals& operator += ( Totals const& other );
2844
2845 Totals delta( Totals const& prevTotals ) const;
2846
2847 int error = 0;
2848 Counts assertions;
2849 Counts testCases;
2850 };
2851 }
2852
2853 // end catch_totals.h
2854 #include <string>
2855
2856 namespace Catch {
2857
2858 struct SectionInfo {
2859 SectionInfo
2860 ( SourceLineInfo const& _lineInfo,
2861 std::string const& _name );
2862
2863 // Deprecated
2864 SectionInfo
2865 ( SourceLineInfo const& _lineInfo,
2866 std::string const& _name,
2867 std::string const& ) : SectionInfo( _lineInfo, _name ) {}
2868
2869 std::string name;
2870 std::string description; // !Deprecated: this will always be empty
2871 SourceLineInfo lineInfo;
2872 };
2873
2874 struct SectionEndInfo {
2875 SectionInfo sectionInfo;
2876 Counts prevAssertions;
2877 double durationInSeconds;
2878 };
2879
2880 } // end namespace Catch
2881
2882 // end catch_section_info.h
2883 // start catch_timer.h
2884
2885 #include <cstdint>
2886
2887 namespace Catch {
2888
2889 auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
2890 auto getEstimatedClockResolution() -> uint64_t;
2891
2892 class Timer {
2893 uint64_t m_nanoseconds = 0;
2894 public:
2895 void start();
2896 auto getElapsedNanoseconds() const -> uint64_t;
2897 auto getElapsedMicroseconds() const -> uint64_t;
2898 auto getElapsedMilliseconds() const -> unsigned int;
2899 auto getElapsedSeconds() const -> double;
2900 };
2901
2902 } // namespace Catch
2903
2904 // end catch_timer.h
2905 #include <string>
2906
2907 namespace Catch {
2908
2909 class Section : NonCopyable {
2910 public:
2911 Section( SectionInfo const& info );
2912 ~Section();
2913
2914 // This indicates whether the section should be executed or not
2915 explicit operator bool() const;
2916
2917 private:
2918 SectionInfo m_info;
2919
2920 std::string m_name;
2921 Counts m_assertions;
2922 bool m_sectionIncluded;
2923 Timer m_timer;
2924 };
2925
2926 } // end namespace Catch
2927
2928 #define INTERNAL_CATCH_SECTION( ... ) \
2929 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
2930 CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
2931 if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
2932 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
2933
2934 #define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
2935 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
2936 CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
2937 if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
2938 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
2939
2940 // end catch_section.h
2941 // start catch_interfaces_exception.h
2942
2943 // start catch_interfaces_registry_hub.h
2944
2945 #include <string>
2946 #include <memory>
2947
2948 namespace Catch {
2949
2950 class TestCase;
2951 struct ITestCaseRegistry;
2952 struct IExceptionTranslatorRegistry;
2953 struct IExceptionTranslator;
2954 struct IReporterRegistry;
2955 struct IReporterFactory;
2956 struct ITagAliasRegistry;
2957 struct IMutableEnumValuesRegistry;
2958
2959 class StartupExceptionRegistry;
2960
2961 using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
2962
2963 struct IRegistryHub {
2964 virtual ~IRegistryHub();
2965
2966 virtual IReporterRegistry const& getReporterRegistry() const = 0;
2967 virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
2968 virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
2969 virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
2970
2971 virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
2972 };
2973
2974 struct IMutableRegistryHub {
2975 virtual ~IMutableRegistryHub();
2976 virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
2977 virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
2978 virtual void registerTest( TestCase const& testInfo ) = 0;
2979 virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
2980 virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
2981 virtual void registerStartupException() noexcept = 0;
2982 virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
2983 };
2984
2985 IRegistryHub const& getRegistryHub();
2986 IMutableRegistryHub& getMutableRegistryHub();
2987 void cleanUp();
2988 std::string translateActiveException();
2989
2990 }
2991
2992 // end catch_interfaces_registry_hub.h
2993 #if defined(CATCH_CONFIG_DISABLE)
2994 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
2995 static std::string translatorName( signature )
2996 #endif
2997
2998 #include <exception>
2999 #include <string>
3000 #include <vector>
3001
3002 namespace Catch {
3003 using exceptionTranslateFunction = std::string(*)();
3004
3005 struct IExceptionTranslator;
3006 using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
3007
3008 struct IExceptionTranslator {
3009 virtual ~IExceptionTranslator();
3010 virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
3011 };
3012
3013 struct IExceptionTranslatorRegistry {
3014 virtual ~IExceptionTranslatorRegistry();
3015
3016 virtual std::string translateActiveException() const = 0;
3017 };
3018
3019 class ExceptionTranslatorRegistrar {
3020 template<typename T>
3021 class ExceptionTranslator : public IExceptionTranslator {
3022 public:
3023
3024 ExceptionTranslator( std::string(*translateFunction)( T& ) )
3025 : m_translateFunction( translateFunction )
3026 {}
3027
3028 std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
3029 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
3030 return "";
3031 #else
3032 try {
3033 if( it == itEnd )
3034 std::rethrow_exception(std::current_exception());
3035 else
3036 return (*it)->translate( it+1, itEnd );
3037 }
3038 catch( T& ex ) {
3039 return m_translateFunction( ex );
3040 }
3041 #endif
3042 }
3043
3044 protected:
3045 std::string(*m_translateFunction)( T& );
3046 };
3047
3048 public:
3049 template<typename T>
3050 ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
3051 getMutableRegistryHub().registerTranslator
3052 ( new ExceptionTranslator<T>( translateFunction ) );
3053 }
3054 };
3055 }
3056
3057 ///////////////////////////////////////////////////////////////////////////////
3058 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
3059 static std::string translatorName( signature ); \
3060 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
3061 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
3062 namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
3063 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
3064 static std::string translatorName( signature )
3065
3066 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
3067
3068 // end catch_interfaces_exception.h
3069 // start catch_approx.h
3070
3071 #include <type_traits>
3072
3073 namespace Catch {
3074 namespace Detail {
3075
3076 class Approx {
3077 private:
3078 bool equalityComparisonImpl(double other) const;
3079 // Validates the new margin (margin >= 0)
3080 // out-of-line to avoid including stdexcept in the header
3081 void setMargin(double margin);
3082 // Validates the new epsilon (0 < epsilon < 1)
3083 // out-of-line to avoid including stdexcept in the header
3084 void setEpsilon(double epsilon);
3085
3086 public:
3087 explicit Approx ( double value );
3088
3089 static Approx custom();
3090
3091 Approx operator-() const;
3092
3093 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3094 Approx operator()( T const& value ) {
3095 Approx approx( static_cast<double>(value) );
3096 approx.m_epsilon = m_epsilon;
3097 approx.m_margin = m_margin;
3098 approx.m_scale = m_scale;
3099 return approx;
3100 }
3101
3102 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3103 explicit Approx( T const& value ): Approx(static_cast<double>(value))
3104 {}
3105
3106 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3107 friend bool operator == ( const T& lhs, Approx const& rhs ) {
3108 auto lhs_v = static_cast<double>(lhs);
3109 return rhs.equalityComparisonImpl(lhs_v);
3110 }
3111
3112 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3113 friend bool operator == ( Approx const& lhs, const T& rhs ) {
3114 return operator==( rhs, lhs );
3115 }
3116
3117 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3118 friend bool operator != ( T const& lhs, Approx const& rhs ) {
3119 return !operator==( lhs, rhs );
3120 }
3121
3122 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3123 friend bool operator != ( Approx const& lhs, T const& rhs ) {
3124 return !operator==( rhs, lhs );
3125 }
3126
3127 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3128 friend bool operator <= ( T const& lhs, Approx const& rhs ) {
3129 return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
3130 }
3131
3132 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3133 friend bool operator <= ( Approx const& lhs, T const& rhs ) {
3134 return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
3135 }
3136
3137 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3138 friend bool operator >= ( T const& lhs, Approx const& rhs ) {
3139 return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
3140 }
3141
3142 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3143 friend bool operator >= ( Approx const& lhs, T const& rhs ) {
3144 return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
3145 }
3146
3147 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3148 Approx& epsilon( T const& newEpsilon ) {
3149 double epsilonAsDouble = static_cast<double>(newEpsilon);
3150 setEpsilon(epsilonAsDouble);
3151 return *this;
3152 }
3153
3154 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3155 Approx& margin( T const& newMargin ) {
3156 double marginAsDouble = static_cast<double>(newMargin);
3157 setMargin(marginAsDouble);
3158 return *this;
3159 }
3160
3161 template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3162 Approx& scale( T const& newScale ) {
3163 m_scale = static_cast<double>(newScale);
3164 return *this;
3165 }
3166
3167 std::string toString() const;
3168
3169 private:
3170 double m_epsilon;
3171 double m_margin;
3172 double m_scale;
3173 double m_value;
3174 };
3175 } // end namespace Detail
3176
3177 namespace literals {
3178 Detail::Approx operator "" _a(long double val);
3179 Detail::Approx operator "" _a(unsigned long long val);
3180 } // end namespace literals
3181
3182 template<>
3183 struct StringMaker<Catch::Detail::Approx> {
3184 static std::string convert(Catch::Detail::Approx const& value);
3185 };
3186
3187 } // end namespace Catch
3188
3189 // end catch_approx.h
3190 // start catch_string_manip.h
3191
3192 #include <string>
3193 #include <iosfwd>
3194 #include <vector>
3195
3196 namespace Catch {
3197
3198 bool startsWith( std::string const& s, std::string const& prefix );
3199 bool startsWith( std::string const& s, char prefix );
3200 bool endsWith( std::string const& s, std::string const& suffix );
3201 bool endsWith( std::string const& s, char suffix );
3202 bool contains( std::string const& s, std::string const& infix );
3203 void toLowerInPlace( std::string& s );
3204 std::string toLower( std::string const& s );
3205 //! Returns a new string without whitespace at the start/end
3206 std::string trim( std::string const& str );
3207 //! Returns a substring of the original ref without whitespace. Beware lifetimes!
3208 StringRef trim(StringRef ref);
3209
3210 // !!! Be aware, returns refs into original string - make sure original string outlives them
3211 std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
3212 bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
3213
3214 struct pluralise {
3215 pluralise( std::size_t count, std::string const& label );
3216
3217 friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
3218
3219 std::size_t m_count;
3220 std::string m_label;
3221 };
3222 }
3223
3224 // end catch_string_manip.h
3225 #ifndef CATCH_CONFIG_DISABLE_MATCHERS
3226 // start catch_capture_matchers.h
3227
3228 // start catch_matchers.h
3229
3230 #include <string>
3231 #include <vector>
3232
3233 namespace Catch {
3234 namespace Matchers {
3235 namespace Impl {
3236
3237 template<typename ArgT> struct MatchAllOf;
3238 template<typename ArgT> struct MatchAnyOf;
3239 template<typename ArgT> struct MatchNotOf;
3240
3241 class MatcherUntypedBase {
3242 public:
3243 MatcherUntypedBase() = default;
3244 MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
3245 MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
3246 std::string toString() const;
3247
3248 protected:
3249 virtual ~MatcherUntypedBase();
3250 virtual std::string describe() const = 0;
3251 mutable std::string m_cachedToString;
3252 };
3253
3254 #ifdef __clang__
3255 # pragma clang diagnostic push
3256 # pragma clang diagnostic ignored "-Wnon-virtual-dtor"
3257 #endif
3258
3259 template<typename ObjectT>
3260 struct MatcherMethod {
3261 virtual bool match( ObjectT const& arg ) const = 0;
3262 };
3263
3264 #if defined(__OBJC__)
3265 // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
3266 // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
3267 template<>
3268 struct MatcherMethod<NSString*> {
3269 virtual bool match( NSString* arg ) const = 0;
3270 };
3271 #endif
3272
3273 #ifdef __clang__
3274 # pragma clang diagnostic pop
3275 #endif
3276
3277 template<typename T>
3278 struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
3279
3280 MatchAllOf<T> operator && ( MatcherBase const& other ) const;
3281 MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
3282 MatchNotOf<T> operator ! () const;
3283 };
3284
3285 template<typename ArgT>
3286 struct MatchAllOf : MatcherBase<ArgT> {
3287 bool match( ArgT const& arg ) const override {
3288 for( auto matcher : m_matchers ) {
3289 if (!matcher->match(arg))
3290 return false;
3291 }
3292 return true;
3293 }
3294 std::string describe() const override {
3295 std::string description;
3296 description.reserve( 4 + m_matchers.size()*32 );
3297 description += "( ";
3298 bool first = true;
3299 for( auto matcher : m_matchers ) {
3300 if( first )
3301 first = false;
3302 else
3303 description += " and ";
3304 description += matcher->toString();
3305 }
3306 description += " )";
3307 return description;
3308 }
3309
3310 MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
3311 auto copy(*this);
3312 copy.m_matchers.push_back( &other );
3313 return copy;
3314 }
3315
3316 std::vector<MatcherBase<ArgT> const*> m_matchers;
3317 };
3318 template<typename ArgT>
3319 struct MatchAnyOf : MatcherBase<ArgT> {
3320
3321 bool match( ArgT const& arg ) const override {
3322 for( auto matcher : m_matchers ) {
3323 if (matcher->match(arg))
3324 return true;
3325 }
3326 return false;
3327 }
3328 std::string describe() const override {
3329 std::string description;
3330 description.reserve( 4 + m_matchers.size()*32 );
3331 description += "( ";
3332 bool first = true;
3333 for( auto matcher : m_matchers ) {
3334 if( first )
3335 first = false;
3336 else
3337 description += " or ";
3338 description += matcher->toString();
3339 }
3340 description += " )";
3341 return description;
3342 }
3343
3344 MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
3345 auto copy(*this);
3346 copy.m_matchers.push_back( &other );
3347 return copy;
3348 }
3349
3350 std::vector<MatcherBase<ArgT> const*> m_matchers;
3351 };
3352
3353 template<typename ArgT>
3354 struct MatchNotOf : MatcherBase<ArgT> {
3355
3356 MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
3357
3358 bool match( ArgT const& arg ) const override {
3359 return !m_underlyingMatcher.match( arg );
3360 }
3361
3362 std::string describe() const override {
3363 return "not " + m_underlyingMatcher.toString();
3364 }
3365 MatcherBase<ArgT> const& m_underlyingMatcher;
3366 };
3367
3368 template<typename T>
3369 MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
3370 return MatchAllOf<T>() && *this && other;
3371 }
3372 template<typename T>
3373 MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
3374 return MatchAnyOf<T>() || *this || other;
3375 }
3376 template<typename T>
3377 MatchNotOf<T> MatcherBase<T>::operator ! () const {
3378 return MatchNotOf<T>( *this );
3379 }
3380
3381 } // namespace Impl
3382
3383 } // namespace Matchers
3384
3385 using namespace Matchers;
3386 using Matchers::Impl::MatcherBase;
3387
3388 } // namespace Catch
3389
3390 // end catch_matchers.h
3391 // start catch_matchers_exception.hpp
3392
3393 namespace Catch {
3394 namespace Matchers {
3395 namespace Exception {
3396
3397 class ExceptionMessageMatcher : public MatcherBase<std::exception> {
3398 std::string m_message;
3399 public:
3400
3401 ExceptionMessageMatcher(std::string const& message):
3402 m_message(message)
3403 {}
3404
3405 bool match(std::exception const& ex) const override;
3406
3407 std::string describe() const override;
3408 };
3409
3410 } // namespace Exception
3411
3412 Exception::ExceptionMessageMatcher Message(std::string const& message);
3413
3414 } // namespace Matchers
3415 } // namespace Catch
3416
3417 // end catch_matchers_exception.hpp
3418 // start catch_matchers_floating.h
3419
3420 namespace Catch {
3421 namespace Matchers {
3422
3423 namespace Floating {
3424
3425 enum class FloatingPointKind : uint8_t;
3426
3427 struct WithinAbsMatcher : MatcherBase<double> {
3428 WithinAbsMatcher(double target, double margin);
3429 bool match(double const& matchee) const override;
3430 std::string describe() const override;
3431 private:
3432 double m_target;
3433 double m_margin;
3434 };
3435
3436 struct WithinUlpsMatcher : MatcherBase<double> {
3437 WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
3438 bool match(double const& matchee) const override;
3439 std::string describe() const override;
3440 private:
3441 double m_target;
3442 uint64_t m_ulps;
3443 FloatingPointKind m_type;
3444 };
3445
3446 // Given IEEE-754 format for floats and doubles, we can assume
3447 // that float -> double promotion is lossless. Given this, we can
3448 // assume that if we do the standard relative comparison of
3449 // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
3450 // the same result if we do this for floats, as if we do this for
3451 // doubles that were promoted from floats.
3452 struct WithinRelMatcher : MatcherBase<double> {
3453 WithinRelMatcher(double target, double epsilon);
3454 bool match(double const& matchee) const override;
3455 std::string describe() const override;
3456 private:
3457 double m_target;
3458 double m_epsilon;
3459 };
3460
3461 } // namespace Floating
3462
3463 // The following functions create the actual matcher objects.
3464 // This allows the types to be inferred
3465 Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
3466 Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
3467 Floating::WithinAbsMatcher WithinAbs(double target, double margin);
3468 Floating::WithinRelMatcher WithinRel(double target, double eps);
3469 // defaults epsilon to 100*numeric_limits<double>::epsilon()
3470 Floating::WithinRelMatcher WithinRel(double target);
3471 Floating::WithinRelMatcher WithinRel(float target, float eps);
3472 // defaults epsilon to 100*numeric_limits<float>::epsilon()
3473 Floating::WithinRelMatcher WithinRel(float target);
3474
3475 } // namespace Matchers
3476 } // namespace Catch
3477
3478 // end catch_matchers_floating.h
3479 // start catch_matchers_generic.hpp
3480
3481 #include <functional>
3482 #include <string>
3483
3484 namespace Catch {
3485 namespace Matchers {
3486 namespace Generic {
3487
3488 namespace Detail {
3489 std::string finalizeDescription(const std::string& desc);
3490 }
3491
3492 template <typename T>
3493 class PredicateMatcher : public MatcherBase<T> {
3494 std::function<bool(T const&)> m_predicate;
3495 std::string m_description;
3496 public:
3497
3498 PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
3499 :m_predicate(std::move(elem)),
3500 m_description(Detail::finalizeDescription(descr))
3501 {}
3502
3503 bool match( T const& item ) const override {
3504 return m_predicate(item);
3505 }
3506
3507 std::string describe() const override {
3508 return m_description;
3509 }
3510 };
3511
3512 } // namespace Generic
3513
3514 // The following functions create the actual matcher objects.
3515 // The user has to explicitly specify type to the function, because
3516 // inferring std::function<bool(T const&)> is hard (but possible) and
3517 // requires a lot of TMP.
3518 template<typename T>
3519 Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
3520 return Generic::PredicateMatcher<T>(predicate, description);
3521 }
3522
3523 } // namespace Matchers
3524 } // namespace Catch
3525
3526 // end catch_matchers_generic.hpp
3527 // start catch_matchers_string.h
3528
3529 #include <string>
3530
3531 namespace Catch {
3532 namespace Matchers {
3533
3534 namespace StdString {
3535
3536 struct CasedString
3537 {
3538 CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
3539 std::string adjustString( std::string const& str ) const;
3540 std::string caseSensitivitySuffix() const;
3541
3542 CaseSensitive::Choice m_caseSensitivity;
3543 std::string m_str;
3544 };
3545
3546 struct StringMatcherBase : MatcherBase<std::string> {
3547 StringMatcherBase( std::string const& operation, CasedString const& comparator );
3548 std::string describe() const override;
3549
3550 CasedString m_comparator;
3551 std::string m_operation;
3552 };
3553
3554 struct EqualsMatcher : StringMatcherBase {
3555 EqualsMatcher( CasedString const& comparator );
3556 bool match( std::string const& source ) const override;
3557 };
3558 struct ContainsMatcher : StringMatcherBase {
3559 ContainsMatcher( CasedString const& comparator );
3560 bool match( std::string const& source ) const override;
3561 };
3562 struct StartsWithMatcher : StringMatcherBase {
3563 StartsWithMatcher( CasedString const& comparator );
3564 bool match( std::string const& source ) const override;
3565 };
3566 struct EndsWithMatcher : StringMatcherBase {
3567 EndsWithMatcher( CasedString const& comparator );
3568 bool match( std::string const& source ) const override;
3569 };
3570
3571 struct RegexMatcher : MatcherBase<std::string> {
3572 RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
3573 bool match( std::string const& matchee ) const override;
3574 std::string describe() const override;
3575
3576 private:
3577 std::string m_regex;
3578 CaseSensitive::Choice m_caseSensitivity;
3579 };
3580
3581 } // namespace StdString
3582
3583 // The following functions create the actual matcher objects.
3584 // This allows the types to be inferred
3585
3586 StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
3587 StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
3588 StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
3589 StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
3590 StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
3591
3592 } // namespace Matchers
3593 } // namespace Catch
3594
3595 // end catch_matchers_string.h
3596 // start catch_matchers_vector.h
3597
3598 #include <algorithm>
3599
3600 namespace Catch {
3601 namespace Matchers {
3602
3603 namespace Vector {
3604 template<typename T, typename Alloc>
3605 struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
3606
3607 ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
3608
3609 bool match(std::vector<T, Alloc> const &v) const override {
3610 for (auto const& el : v) {
3611 if (el == m_comparator) {
3612 return true;
3613 }
3614 }
3615 return false;
3616 }
3617
3618 std::string describe() const override {
3619 return "Contains: " + ::Catch::Detail::stringify( m_comparator );
3620 }
3621
3622 T const& m_comparator;
3623 };
3624
3625 template<typename T, typename AllocComp, typename AllocMatch>
3626 struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
3627
3628 ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}
3629
3630 bool match(std::vector<T, AllocMatch> const &v) const override {
3631 // !TBD: see note in EqualsMatcher
3632 if (m_comparator.size() > v.size())
3633 return false;
3634 for (auto const& comparator : m_comparator) {
3635 auto present = false;
3636 for (const auto& el : v) {
3637 if (el == comparator) {
3638 present = true;
3639 break;
3640 }
3641 }
3642 if (!present) {
3643 return false;
3644 }
3645 }
3646 return true;
3647 }
3648 std::string describe() const override {
3649 return "Contains: " + ::Catch::Detail::stringify( m_comparator );
3650 }
3651
3652 std::vector<T, AllocComp> const& m_comparator;
3653 };
3654
3655 template<typename T, typename AllocComp, typename AllocMatch>
3656 struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
3657
3658 EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}
3659
3660 bool match(std::vector<T, AllocMatch> const &v) const override {
3661 // !TBD: This currently works if all elements can be compared using !=
3662 // - a more general approach would be via a compare template that defaults
3663 // to using !=. but could be specialised for, e.g. std::vector<T, Alloc> etc
3664 // - then just call that directly
3665 if (m_comparator.size() != v.size())
3666 return false;
3667 for (std::size_t i = 0; i < v.size(); ++i)
3668 if (m_comparator[i] != v[i])
3669 return false;
3670 return true;
3671 }
3672 std::string describe() const override {
3673 return "Equals: " + ::Catch::Detail::stringify( m_comparator );
3674 }
3675 std::vector<T, AllocComp> const& m_comparator;
3676 };
3677
3678 template<typename T, typename AllocComp, typename AllocMatch>
3679 struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
3680
3681 ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_comparator( comparator ) {}
3682
3683 bool match(std::vector<T, AllocMatch> const &v) const override {
3684 if (m_comparator.size() != v.size())
3685 return false;
3686 for (std::size_t i = 0; i < v.size(); ++i)
3687 if (m_comparator[i] != approx(v[i]))
3688 return false;
3689 return true;
3690 }
3691 std::string describe() const override {
3692 return "is approx: " + ::Catch::Detail::stringify( m_comparator );
3693 }
3694 template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3695 ApproxMatcher& epsilon( T const& newEpsilon ) {
3696 approx.epsilon(newEpsilon);
3697 return *this;
3698 }
3699 template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3700 ApproxMatcher& margin( T const& newMargin ) {
3701 approx.margin(newMargin);
3702 return *this;
3703 }
3704 template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
3705 ApproxMatcher& scale( T const& newScale ) {
3706 approx.scale(newScale);
3707 return *this;
3708 }
3709
3710 std::vector<T, AllocComp> const& m_comparator;
3711 mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
3712 };
3713
3714 template<typename T, typename AllocComp, typename AllocMatch>
3715 struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
3716 UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) : m_target(target) {}
3717 bool match(std::vector<T, AllocMatch> const& vec) const override {
3718 if (m_target.size() != vec.size()) {
3719 return false;
3720 }
3721 return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
3722 }
3723
3724 std::string describe() const override {
3725 return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
3726 }
3727 private:
3728 std::vector<T, AllocComp> const& m_target;
3729 };
3730
3731 } // namespace Vector
3732
3733 // The following functions create the actual matcher objects.
3734 // This allows the types to be inferred
3735
3736 template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
3737 Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
3738 return Vector::ContainsMatcher<T, AllocComp, AllocMatch>( comparator );
3739 }
3740
3741 template<typename T, typename Alloc = std::allocator<T>>
3742 Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
3743 return Vector::ContainsElementMatcher<T, Alloc>( comparator );
3744 }
3745
3746 template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
3747 Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
3748 return Vector::EqualsMatcher<T, AllocComp, AllocMatch>( comparator );
3749 }
3750
3751 template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
3752 Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
3753 return Vector::ApproxMatcher<T, AllocComp, AllocMatch>( comparator );
3754 }
3755
3756 template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
3757 Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
3758 return Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch>( target );
3759 }
3760
3761 } // namespace Matchers
3762 } // namespace Catch
3763
3764 // end catch_matchers_vector.h
3765 namespace Catch {
3766
3767 template<typename ArgT, typename MatcherT>
3768 class MatchExpr : public ITransientExpression {
3769 ArgT const& m_arg;
3770 MatcherT m_matcher;
3771 StringRef m_matcherString;
3772 public:
3773 MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
3774 : ITransientExpression{ true, matcher.match( arg ) },
3775 m_arg( arg ),
3776 m_matcher( matcher ),
3777 m_matcherString( matcherString )
3778 {}
3779
3780 void streamReconstructedExpression( std::ostream &os ) const override {
3781 auto matcherAsString = m_matcher.toString();
3782 os << Catch::Detail::stringify( m_arg ) << ' ';
3783 if( matcherAsString == Detail::unprintableString )
3784 os << m_matcherString;
3785 else
3786 os << matcherAsString;
3787 }
3788 };
3789
3790 using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
3791
3792 void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString );
3793
3794 template<typename ArgT, typename MatcherT>
3795 auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString ) -> MatchExpr<ArgT, MatcherT> {
3796 return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
3797 }
3798
3799 } // namespace Catch
3800
3801 ///////////////////////////////////////////////////////////////////////////////
3802 #define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
3803 do { \
3804 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
3805 INTERNAL_CATCH_TRY { \
3806 catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
3807 } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
3808 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
3809 } while( false )
3810
3811 ///////////////////////////////////////////////////////////////////////////////
3812 #define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
3813 do { \
3814 Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
3815 if( catchAssertionHandler.allowThrows() ) \
3816 try { \
3817 static_cast<void>(__VA_ARGS__ ); \
3818 catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
3819 } \
3820 catch( exceptionType const& ex ) { \
3821 catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
3822 } \
3823 catch( ... ) { \
3824 catchAssertionHandler.handleUnexpectedInflightException(); \
3825 } \
3826 else \
3827 catchAssertionHandler.handleThrowingCallSkipped(); \
3828 INTERNAL_CATCH_REACT( catchAssertionHandler ) \
3829 } while( false )
3830
3831 // end catch_capture_matchers.h
3832 #endif
3833 // start catch_generators.hpp
3834
3835 // start catch_interfaces_generatortracker.h
3836
3837
3838 #include <memory>
3839
3840 namespace Catch {
3841
3842 namespace Generators {
3843 class GeneratorUntypedBase {
3844 public:
3845 GeneratorUntypedBase() = default;
3846 virtual ~GeneratorUntypedBase();
3847 // Attempts to move the generator to the next element
3848 //
3849 // Returns true iff the move succeeded (and a valid element
3850 // can be retrieved).
3851 virtual bool next() = 0;
3852 };
3853 using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
3854
3855 } // namespace Generators
3856
3857 struct IGeneratorTracker {
3858 virtual ~IGeneratorTracker();
3859 virtual auto hasGenerator() const -> bool = 0;
3860 virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
3861 virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
3862 };
3863
3864 } // namespace Catch
3865
3866 // end catch_interfaces_generatortracker.h
3867 // start catch_enforce.h
3868
3869 #include <exception>
3870
3871 namespace Catch {
3872 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
3873 template <typename Ex>
3874 [[noreturn]]
3875 void throw_exception(Ex const& e) {
3876 throw e;
3877 }
3878 #else // ^^ Exceptions are enabled // Exceptions are disabled vv
3879 [[noreturn]]
3880 void throw_exception(std::exception const& e);
3881 #endif
3882
3883 [[noreturn]]
3884 void throw_logic_error(std::string const& msg);
3885 [[noreturn]]
3886 void throw_domain_error(std::string const& msg);
3887 [[noreturn]]
3888 void throw_runtime_error(std::string const& msg);
3889
3890 } // namespace Catch;
3891
3892 #define CATCH_MAKE_MSG(...) \
3893 (Catch::ReusableStringStream() << __VA_ARGS__).str()
3894
3895 #define CATCH_INTERNAL_ERROR(...) \
3896 Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
3897
3898 #define CATCH_ERROR(...) \
3899 Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
3900
3901 #define CATCH_RUNTIME_ERROR(...) \
3902 Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
3903
3904 #define CATCH_ENFORCE( condition, ... ) \
3905 do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
3906
3907 // end catch_enforce.h
3908 #include <memory>
3909 #include <vector>
3910 #include <cassert>
3911
3912 #include <utility>
3913 #include <exception>
3914
3915 namespace Catch {
3916
3917 class GeneratorException : public std::exception {
3918 const char* const m_msg = "";
3919
3920 public:
3921 GeneratorException(const char* msg):
3922 m_msg(msg)
3923 {}
3924
3925 const char* what() const noexcept override final;
3926 };
3927
3928 namespace Generators {
3929
3930 // !TBD move this into its own location?
3931 namespace pf{
3932 template<typename T, typename... Args>
3933 std::unique_ptr<T> make_unique( Args&&... args ) {
3934 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
3935 }
3936 }
3937
3938 template<typename T>
3939 struct IGenerator : GeneratorUntypedBase {
3940 virtual ~IGenerator() = default;
3941
3942 // Returns the current element of the generator
3943 //
3944 // \Precondition The generator is either freshly constructed,
3945 // or the last call to `next()` returned true
3946 virtual T const& get() const = 0;
3947 using type = T;
3948 };
3949
3950 template<typename T>
3951 class SingleValueGenerator final : public IGenerator<T> {
3952 T m_value;
3953 public:
3954 SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
3955
3956 T const& get() const override {
3957 return m_value;
3958 }
3959 bool next() override {
3960 return false;
3961 }
3962 };
3963
3964 template<typename T>
3965 class FixedValuesGenerator final : public IGenerator<T> {
3966 static_assert(!std::is_same<T, bool>::value,
3967 "FixedValuesGenerator does not support bools because of std::vector<bool>"
3968 "specialization, use SingleValue Generator instead.");
3969 std::vector<T> m_values;
3970 size_t m_idx = 0;
3971 public:
3972 FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
3973
3974 T const& get() const override {
3975 return m_values[m_idx];
3976 }
3977 bool next() override {
3978 ++m_idx;
3979 return m_idx < m_values.size();
3980 }
3981 };
3982
3983 template <typename T>
3984 class GeneratorWrapper final {
3985 std::unique_ptr<IGenerator<T>> m_generator;
3986 public:
3987 GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
3988 m_generator(std::move(generator))
3989 {}
3990 T const& get() const {
3991 return m_generator->get();
3992 }
3993 bool next() {
3994 return m_generator->next();
3995 }
3996 };
3997
3998 template <typename T>
3999 GeneratorWrapper<T> value(T&& value) {
4000 return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
4001 }
4002 template <typename T>
4003 GeneratorWrapper<T> values(std::initializer_list<T> values) {
4004 return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
4005 }
4006
4007 template<typename T>
4008 class Generators : public IGenerator<T> {
4009 std::vector<GeneratorWrapper<T>> m_generators;
4010 size_t m_current = 0;
4011
4012 void populate(GeneratorWrapper<T>&& generator) {
4013 m_generators.emplace_back(std::move(generator));
4014 }
4015 void populate(T&& val) {
4016 m_generators.emplace_back(value(std::forward<T>(val)));
4017 }
4018 template<typename U>
4019 void populate(U&& val) {
4020 populate(T(std::forward<U>(val)));
4021 }
4022 template<typename U, typename... Gs>
4023 void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
4024 populate(std::forward<U>(valueOrGenerator));
4025 populate(std::forward<Gs>(moreGenerators)...);
4026 }
4027
4028 public:
4029 template <typename... Gs>
4030 Generators(Gs &&... moreGenerators) {
4031 m_generators.reserve(sizeof...(Gs));
4032 populate(std::forward<Gs>(moreGenerators)...);
4033 }
4034
4035 T const& get() const override {
4036 return m_generators[m_current].get();
4037 }
4038
4039 bool next() override {
4040 if (m_current >= m_generators.size()) {
4041 return false;
4042 }
4043 const bool current_status = m_generators[m_current].next();
4044 if (!current_status) {
4045 ++m_current;
4046 }
4047 return m_current < m_generators.size();
4048 }
4049 };
4050
4051 template<typename... Ts>
4052 GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
4053 return values<std::tuple<Ts...>>( tuples );
4054 }
4055
4056 // Tag type to signal that a generator sequence should convert arguments to a specific type
4057 template <typename T>
4058 struct as {};
4059
4060 template<typename T, typename... Gs>
4061 auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
4062 return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
4063 }
4064 template<typename T>
4065 auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
4066 return Generators<T>(std::move(generator));
4067 }
4068 template<typename T, typename... Gs>
4069 auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
4070 return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
4071 }
4072 template<typename T, typename U, typename... Gs>
4073 auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
4074 return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
4075 }
4076
4077 auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
4078
4079 template<typename L>
4080 // Note: The type after -> is weird, because VS2015 cannot parse
4081 // the expression used in the typedef inside, when it is in
4082 // return type. Yeah.
4083 auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
4084 using UnderlyingType = typename decltype(generatorExpression())::type;
4085
4086 IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
4087 if (!tracker.hasGenerator()) {
4088 tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
4089 }
4090
4091 auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
4092 return generator.get();
4093 }
4094
4095 } // namespace Generators
4096 } // namespace Catch
4097
4098 #define GENERATE( ... ) \
4099 Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
4100 CATCH_INTERNAL_LINEINFO, \
4101 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
4102 #define GENERATE_COPY( ... ) \
4103 Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
4104 CATCH_INTERNAL_LINEINFO, \
4105 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
4106 #define GENERATE_REF( ... ) \
4107 Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
4108 CATCH_INTERNAL_LINEINFO, \
4109 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
4110
4111 // end catch_generators.hpp
4112 // start catch_generators_generic.hpp
4113
4114 namespace Catch {
4115 namespace Generators {
4116
4117 template <typename T>
4118 class TakeGenerator : public IGenerator<T> {
4119 GeneratorWrapper<T> m_generator;
4120 size_t m_returned = 0;
4121 size_t m_target;
4122 public:
4123 TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
4124 m_generator(std::move(generator)),
4125 m_target(target)
4126 {
4127 assert(target != 0 && "Empty generators are not allowed");
4128 }
4129 T const& get() const override {
4130 return m_generator.get();
4131 }
4132 bool next() override {
4133 ++m_returned;
4134 if (m_returned >= m_target) {
4135 return false;
4136 }
4137
4138 const auto success = m_generator.next();
4139 // If the underlying generator does not contain enough values
4140 // then we cut short as well
4141 if (!success) {
4142 m_returned = m_target;
4143 }
4144 return success;
4145 }
4146 };
4147
4148 template <typename T>
4149 GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
4150 return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
4151 }
4152
4153 template <typename T, typename Predicate>
4154 class FilterGenerator : public IGenerator<T> {
4155 GeneratorWrapper<T> m_generator;
4156 Predicate m_predicate;
4157 public:
4158 template <typename P = Predicate>
4159 FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
4160 m_generator(std::move(generator)),
4161 m_predicate(std::forward<P>(pred))
4162 {
4163 if (!m_predicate(m_generator.get())) {
4164 // It might happen that there are no values that pass the
4165 // filter. In that case we throw an exception.
4166 auto has_initial_value = next();
4167 if (!has_initial_value) {
4168 Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
4169 }
4170 }
4171 }
4172
4173 T const& get() const override {
4174 return m_generator.get();
4175 }
4176
4177 bool next() override {
4178 bool success = m_generator.next();
4179 if (!success) {
4180 return false;
4181 }
4182 while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
4183 return success;
4184 }
4185 };
4186
4187 template <typename T, typename Predicate>
4188 GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
4189 return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
4190 }
4191
4192 template <typename T>
4193 class RepeatGenerator : public IGenerator<T> {
4194 static_assert(!std::is_same<T, bool>::value,
4195 "RepeatGenerator currently does not support bools"
4196 "because of std::vector<bool> specialization");
4197 GeneratorWrapper<T> m_generator;
4198 mutable std::vector<T> m_returned;
4199 size_t m_target_repeats;
4200 size_t m_current_repeat = 0;
4201 size_t m_repeat_index = 0;
4202 public:
4203 RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
4204 m_generator(std::move(generator)),
4205 m_target_repeats(repeats)
4206 {
4207 assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
4208 }
4209
4210 T const& get() const override {
4211 if (m_current_repeat == 0) {
4212 m_returned.push_back(m_generator.get());
4213 return m_returned.back();
4214 }
4215 return m_returned[m_repeat_index];
4216 }
4217
4218 bool next() override {
4219 // There are 2 basic cases:
4220 // 1) We are still reading the generator
4221 // 2) We are reading our own cache
4222
4223 // In the first case, we need to poke the underlying generator.
4224 // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
4225 if (m_current_repeat == 0) {
4226 const auto success = m_generator.next();
4227 if (!success) {
4228 ++m_current_repeat;
4229 }
4230 return m_current_repeat < m_target_repeats;
4231 }
4232
4233 // In the second case, we need to move indices forward and check that we haven't run up against the end
4234 ++m_repeat_index;
4235 if (m_repeat_index == m_returned.size()) {
4236 m_repeat_index = 0;
4237 ++m_current_repeat;
4238 }
4239 return m_current_repeat < m_target_repeats;
4240 }
4241 };
4242
4243 template <typename T>
4244 GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
4245 return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
4246 }
4247
4248 template <typename T, typename U, typename Func>
4249 class MapGenerator : public IGenerator<T> {
4250 // TBD: provide static assert for mapping function, for friendly error message
4251 GeneratorWrapper<U> m_generator;
4252 Func m_function;
4253 // To avoid returning dangling reference, we have to save the values
4254 T m_cache;
4255 public:
4256 template <typename F2 = Func>
4257 MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
4258 m_generator(std::move(generator)),
4259 m_function(std::forward<F2>(function)),
4260 m_cache(m_function(m_generator.get()))
4261 {}
4262
4263 T const& get() const override {
4264 return m_cache;
4265 }
4266 bool next() override {
4267 const auto success = m_generator.next();
4268 if (success) {
4269 m_cache = m_function(m_generator.get());
4270 }
4271 return success;
4272 }
4273 };
4274
4275 template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
4276 GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
4277 return GeneratorWrapper<T>(
4278 pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
4279 );
4280 }
4281
4282 template <typename T, typename U, typename Func>
4283 GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
4284 return GeneratorWrapper<T>(
4285 pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
4286 );
4287 }
4288
4289 template <typename T>
4290 class ChunkGenerator final : public IGenerator<std::vector<T>> {
4291 std::vector<T> m_chunk;
4292 size_t m_chunk_size;
4293 GeneratorWrapper<T> m_generator;
4294 bool m_used_up = false;
4295 public:
4296 ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
4297 m_chunk_size(size), m_generator(std::move(generator))
4298 {
4299 m_chunk.reserve(m_chunk_size);
4300 if (m_chunk_size != 0) {
4301 m_chunk.push_back(m_generator.get());
4302 for (size_t i = 1; i < m_chunk_size; ++i) {
4303 if (!m_generator.next()) {
4304 Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
4305 }
4306 m_chunk.push_back(m_generator.get());
4307 }
4308 }
4309 }
4310 std::vector<T> const& get() const override {
4311 return m_chunk;
4312 }
4313 bool next() override {
4314 m_chunk.clear();
4315 for (size_t idx = 0; idx < m_chunk_size; ++idx) {
4316 if (!m_generator.next()) {
4317 return false;
4318 }
4319 m_chunk.push_back(m_generator.get());
4320 }
4321 return true;
4322 }
4323 };
4324
4325 template <typename T>
4326 GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
4327 return GeneratorWrapper<std::vector<T>>(
4328 pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
4329 );
4330 }
4331
4332 } // namespace Generators
4333 } // namespace Catch
4334
4335 // end catch_generators_generic.hpp
4336 // start catch_generators_specific.hpp
4337
4338 // start catch_context.h
4339
4340 #include <memory>
4341
4342 namespace Catch {
4343
4344 struct IResultCapture;
4345 struct IRunner;
4346 struct IConfig;
4347 struct IMutableContext;
4348
4349 using IConfigPtr = std::shared_ptr<IConfig const>;
4350
4351 struct IContext
4352 {
4353 virtual ~IContext();
4354
4355 virtual IResultCapture* getResultCapture() = 0;
4356 virtual IRunner* getRunner() = 0;
4357 virtual IConfigPtr const& getConfig() const = 0;
4358 };
4359
4360 struct IMutableContext : IContext
4361 {
4362 virtual ~IMutableContext();
4363 virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
4364 virtual void setRunner( IRunner* runner ) = 0;
4365 virtual void setConfig( IConfigPtr const& config ) = 0;
4366
4367 private:
4368 static IMutableContext *currentContext;
4369 friend IMutableContext& getCurrentMutableContext();
4370 friend void cleanUpContext();
4371 static void createContext();
4372 };
4373
4374 inline IMutableContext& getCurrentMutableContext()
4375 {
4376 if( !IMutableContext::currentContext )
4377 IMutableContext::createContext();
4378 // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
4379 return *IMutableContext::currentContext;
4380 }
4381
4382 inline IContext& getCurrentContext()
4383 {
4384 return getCurrentMutableContext();
4385 }
4386
4387 void cleanUpContext();
4388
4389 class SimplePcg32;
4390 SimplePcg32& rng();
4391 }
4392
4393 // end catch_context.h
4394 // start catch_interfaces_config.h
4395
4396 // start catch_option.hpp
4397
4398 namespace Catch {
4399
4400 // An optional type
4401 template<typename T>
4402 class Option {
4403 public:
4404 Option() : nullableValue( nullptr ) {}
4405 Option( T const& _value )
4406 : nullableValue( new( storage ) T( _value ) )
4407 {}
4408 Option( Option const& _other )
4409 : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
4410 {}
4411
4412 ~Option() {
4413 reset();
4414 }
4415
4416 Option& operator= ( Option const& _other ) {
4417 if( &_other != this ) {
4418 reset();
4419 if( _other )
4420 nullableValue = new( storage ) T( *_other );
4421 }
4422 return *this;
4423 }
4424 Option& operator = ( T const& _value ) {
4425 reset();
4426 nullableValue = new( storage ) T( _value );
4427 return *this;
4428 }
4429
4430 void reset() {
4431 if( nullableValue )
4432 nullableValue->~T();
4433 nullableValue = nullptr;
4434 }
4435
4436 T& operator*() { return *nullableValue; }
4437 T const& operator*() const { return *nullableValue; }
4438 T* operator->() { return nullableValue; }
4439 const T* operator->() const { return nullableValue; }
4440
4441 T valueOr( T const& defaultValue ) const {
4442 return nullableValue ? *nullableValue : defaultValue;
4443 }
4444
4445 bool some() const { return nullableValue != nullptr; }
4446 bool none() const { return nullableValue == nullptr; }
4447
4448 bool operator !() const { return nullableValue == nullptr; }
4449 explicit operator bool() const {
4450 return some();
4451 }
4452
4453 private:
4454 T *nullableValue;
4455 alignas(alignof(T)) char storage[sizeof(T)];
4456 };
4457
4458 } // end namespace Catch
4459
4460 // end catch_option.hpp
4461 #include <chrono>
4462 #include <iosfwd>
4463 #include <string>
4464 #include <vector>
4465 #include <memory>
4466
4467 namespace Catch {
4468
4469 enum class Verbosity {
4470 Quiet = 0,
4471 Normal,
4472 High
4473 };
4474
4475 struct WarnAbout { enum What {
4476 Nothing = 0x00,
4477 NoAssertions = 0x01,
4478 NoTests = 0x02
4479 }; };
4480
4481 struct ShowDurations { enum OrNot {
4482 DefaultForReporter,
4483 Always,
4484 Never
4485 }; };
4486 struct RunTests { enum InWhatOrder {
4487 InDeclarationOrder,
4488 InLexicographicalOrder,
4489 InRandomOrder
4490 }; };
4491 struct UseColour { enum YesOrNo {
4492 Auto,
4493 Yes,
4494 No
4495 }; };
4496 struct WaitForKeypress { enum When {
4497 Never,
4498 BeforeStart = 1,
4499 BeforeExit = 2,
4500 BeforeStartAndExit = BeforeStart | BeforeExit
4501 }; };
4502
4503 class TestSpec;
4504
4505 struct IConfig : NonCopyable {
4506
4507 virtual ~IConfig();
4508
4509 virtual bool allowThrows() const = 0;
4510 virtual std::ostream& stream() const = 0;
4511 virtual std::string name() const = 0;
4512 virtual bool includeSuccessfulResults() const = 0;
4513 virtual bool shouldDebugBreak() const = 0;
4514 virtual bool warnAboutMissingAssertions() const = 0;
4515 virtual bool warnAboutNoTests() const = 0;
4516 virtual int abortAfter() const = 0;
4517 virtual bool showInvisibles() const = 0;
4518 virtual ShowDurations::OrNot showDurations() const = 0;
4519 virtual double minDuration() const = 0;
4520 virtual TestSpec const& testSpec() const = 0;
4521 virtual bool hasTestFilters() const = 0;
4522 virtual std::vector<std::string> const& getTestsOrTags() const = 0;
4523 virtual RunTests::InWhatOrder runOrder() const = 0;
4524 virtual unsigned int rngSeed() const = 0;
4525 virtual UseColour::YesOrNo useColour() const = 0;
4526 virtual std::vector<std::string> const& getSectionsToRun() const = 0;
4527 virtual Verbosity verbosity() const = 0;
4528
4529 virtual bool benchmarkNoAnalysis() const = 0;
4530 virtual int benchmarkSamples() const = 0;
4531 virtual double benchmarkConfidenceInterval() const = 0;
4532 virtual unsigned int benchmarkResamples() const = 0;
4533 virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
4534 };
4535
4536 using IConfigPtr = std::shared_ptr<IConfig const>;
4537 }
4538
4539 // end catch_interfaces_config.h
4540 // start catch_random_number_generator.h
4541
4542 #include <cstdint>
4543
4544 namespace Catch {
4545
4546 // This is a simple implementation of C++11 Uniform Random Number
4547 // Generator. It does not provide all operators, because Catch2
4548 // does not use it, but it should behave as expected inside stdlib's
4549 // distributions.
4550 // The implementation is based on the PCG family (http://pcg-random.org)
4551 class SimplePcg32 {
4552 using state_type = std::uint64_t;
4553 public:
4554 using result_type = std::uint32_t;
4555 static constexpr result_type (min)() {
4556 return 0;
4557 }
4558 static constexpr result_type (max)() {
4559 return static_cast<result_type>(-1);
4560 }
4561
4562 // Provide some default initial state for the default constructor
4563 SimplePcg32():SimplePcg32(0xed743cc4U) {}
4564
4565 explicit SimplePcg32(result_type seed_);
4566
4567 void seed(result_type seed_);
4568 void discard(uint64_t skip);
4569
4570 result_type operator()();
4571
4572 private:
4573 friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
4574 friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
4575
4576 // In theory we also need operator<< and operator>>
4577 // In practice we do not use them, so we will skip them for now
4578
4579 std::uint64_t m_state;
4580 // This part of the state determines which "stream" of the numbers
4581 // is chosen -- we take it as a constant for Catch2, so we only
4582 // need to deal with seeding the main state.
4583 // Picked by reading 8 bytes from `/dev/random` :-)
4584 static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
4585 };
4586
4587 } // end namespace Catch
4588
4589 // end catch_random_number_generator.h
4590 #include <random>
4591
4592 namespace Catch {
4593 namespace Generators {
4594
4595 template <typename Float>
4596 class RandomFloatingGenerator final : public IGenerator<Float> {
4597 Catch::SimplePcg32& m_rng;
4598 std::uniform_real_distribution<Float> m_dist;
4599 Float m_current_number;
4600 public:
4601
4602 RandomFloatingGenerator(Float a, Float b):
4603 m_rng(rng()),
4604 m_dist(a, b) {
4605 static_cast<void>(next());
4606 }
4607
4608 Float const& get() const override {
4609 return m_current_number;
4610 }
4611 bool next() override {
4612 m_current_number = m_dist(m_rng);
4613 return true;
4614 }
4615 };
4616
4617 template <typename Integer>
4618 class RandomIntegerGenerator final : public IGenerator<Integer> {
4619 Catch::SimplePcg32& m_rng;
4620 std::uniform_int_distribution<Integer> m_dist;
4621 Integer m_current_number;
4622 public:
4623
4624 RandomIntegerGenerator(Integer a, Integer b):
4625 m_rng(rng()),
4626 m_dist(a, b) {
4627 static_cast<void>(next());
4628 }
4629
4630 Integer const& get() const override {
4631 return m_current_number;
4632 }
4633 bool next() override {
4634 m_current_number = m_dist(m_rng);
4635 return true;
4636 }
4637 };
4638
4639 // TODO: Ideally this would be also constrained against the various char types,
4640 // but I don't expect users to run into that in practice.
4641 template <typename T>
4642 typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
4643 GeneratorWrapper<T>>::type
4644 random(T a, T b) {
4645 return GeneratorWrapper<T>(
4646 pf::make_unique<RandomIntegerGenerator<T>>(a, b)
4647 );
4648 }
4649
4650 template <typename T>
4651 typename std::enable_if<std::is_floating_point<T>::value,
4652 GeneratorWrapper<T>>::type
4653 random(T a, T b) {
4654 return GeneratorWrapper<T>(
4655 pf::make_unique<RandomFloatingGenerator<T>>(a, b)
4656 );
4657 }
4658
4659 template <typename T>
4660 class RangeGenerator final : public IGenerator<T> {
4661 T m_current;
4662 T m_end;
4663 T m_step;
4664 bool m_positive;
4665
4666 public:
4667 RangeGenerator(T const& start, T const& end, T const& step):
4668 m_current(start),
4669 m_end(end),
4670 m_step(step),
4671 m_positive(m_step > T(0))
4672 {
4673 assert(m_current != m_end && "Range start and end cannot be equal");
4674 assert(m_step != T(0) && "Step size cannot be zero");
4675 assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
4676 }
4677
4678 RangeGenerator(T const& start, T const& end):
4679 RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
4680 {}
4681
4682 T const& get() const override {
4683 return m_current;
4684 }
4685
4686 bool next() override {
4687 m_current += m_step;
4688 return (m_positive) ? (m_current < m_end) : (m_current > m_end);
4689 }
4690 };
4691
4692 template <typename T>
4693 GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
4694 static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
4695 return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
4696 }
4697
4698 template <typename T>
4699 GeneratorWrapper<T> range(T const& start, T const& end) {
4700 static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
4701 return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
4702 }
4703
4704 template <typename T>
4705 class IteratorGenerator final : public IGenerator<T> {
4706 static_assert(!std::is_same<T, bool>::value,
4707 "IteratorGenerator currently does not support bools"
4708 "because of std::vector<bool> specialization");
4709
4710 std::vector<T> m_elems;
4711 size_t m_current = 0;
4712 public:
4713 template <typename InputIterator, typename InputSentinel>
4714 IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
4715 if (m_elems.empty()) {
4716 Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
4717 }
4718 }
4719
4720 T const& get() const override {
4721 return m_elems[m_current];
4722 }
4723
4724 bool next() override {
4725 ++m_current;
4726 return m_current != m_elems.size();
4727 }
4728 };
4729
4730 template <typename InputIterator,
4731 typename InputSentinel,
4732 typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
4733 GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
4734 return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
4735 }
4736
4737 template <typename Container,
4738 typename ResultType = typename Container::value_type>
4739 GeneratorWrapper<ResultType> from_range(Container const& cnt) {
4740 return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
4741 }
4742
4743 } // namespace Generators
4744 } // namespace Catch
4745
4746 // end catch_generators_specific.hpp
4747
4748 // These files are included here so the single_include script doesn't put them
4749 // in the conditionally compiled sections
4750 // start catch_test_case_info.h
4751
4752 #include <string>
4753 #include <vector>
4754 #include <memory>
4755
4756 #ifdef __clang__
4757 #pragma clang diagnostic push
4758 #pragma clang diagnostic ignored "-Wpadded"
4759 #endif
4760
4761 namespace Catch {
4762
4763 struct ITestInvoker;
4764
4765 struct TestCaseInfo {
4766 enum SpecialProperties{
4767 None = 0,
4768 IsHidden = 1 << 1,
4769 ShouldFail = 1 << 2,
4770 MayFail = 1 << 3,
4771 Throws = 1 << 4,
4772 NonPortable = 1 << 5,
4773 Benchmark = 1 << 6
4774 };
4775
4776 TestCaseInfo( std::string const& _name,
4777 std::string const& _className,
4778 std::string const& _description,
4779 std::vector<std::string> const& _tags,
4780 SourceLineInfo const& _lineInfo );
4781
4782 friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
4783
4784 bool isHidden() const;
4785 bool throws() const;
4786 bool okToFail() const;
4787 bool expectedToFail() const;
4788
4789 std::string tagsAsString() const;
4790
4791 std::string name;
4792 std::string className;
4793 std::string description;
4794 std::vector<std::string> tags;
4795 std::vector<std::string> lcaseTags;
4796 SourceLineInfo lineInfo;
4797 SpecialProperties properties;
4798 };
4799
4800 class TestCase : public TestCaseInfo {
4801 public:
4802
4803 TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
4804
4805 TestCase withName( std::string const& _newName ) const;
4806
4807 void invoke() const;
4808
4809 TestCaseInfo const& getTestCaseInfo() const;
4810
4811 bool operator == ( TestCase const& other ) const;
4812 bool operator < ( TestCase const& other ) const;
4813
4814 private:
4815 std::shared_ptr<ITestInvoker> test;
4816 };
4817
4818 TestCase makeTestCase( ITestInvoker* testCase,
4819 std::string const& className,
4820 NameAndTags const& nameAndTags,
4821 SourceLineInfo const& lineInfo );
4822 }
4823
4824 #ifdef __clang__
4825 #pragma clang diagnostic pop
4826 #endif
4827
4828 // end catch_test_case_info.h
4829 // start catch_interfaces_runner.h
4830
4831 namespace Catch {
4832
4833 struct IRunner {
4834 virtual ~IRunner();
4835 virtual bool aborting() const = 0;
4836 };
4837 }
4838
4839 // end catch_interfaces_runner.h
4840
4841 #ifdef __OBJC__
4842 // start catch_objc.hpp
4843
4844 #import <objc/runtime.h>
4845
4846 #include <string>
4847
4848 // NB. Any general catch headers included here must be included
4849 // in catch.hpp first to make sure they are included by the single
4850 // header for non obj-usage
4851
4852 ///////////////////////////////////////////////////////////////////////////////
4853 // This protocol is really only here for (self) documenting purposes, since
4854 // all its methods are optional.
4855 @protocol OcFixture
4856
4857 @optional
4858
4859 -(void) setUp;
4860 -(void) tearDown;
4861
4862 @end
4863
4864 namespace Catch {
4865
4866 class OcMethod : public ITestInvoker {
4867
4868 public:
4869 OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
4870
4871 virtual void invoke() const {
4872 id obj = [[m_cls alloc] init];
4873
4874 performOptionalSelector( obj, @selector(setUp) );
4875 performOptionalSelector( obj, m_sel );
4876 performOptionalSelector( obj, @selector(tearDown) );
4877
4878 arcSafeRelease( obj );
4879 }
4880 private:
4881 virtual ~OcMethod() {}
4882
4883 Class m_cls;
4884 SEL m_sel;
4885 };
4886
4887 namespace Detail{
4888
4889 inline std::string getAnnotation( Class cls,
4890 std::string const& annotationName,
4891 std::string const& testCaseName ) {
4892 NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
4893 SEL sel = NSSelectorFromString( selStr );
4894 arcSafeRelease( selStr );
4895 id value = performOptionalSelector( cls, sel );
4896 if( value )
4897 return [(NSString*)value UTF8String];
4898 return "";
4899 }
4900 }
4901
4902 inline std::size_t registerTestMethods() {
4903 std::size_t noTestMethods = 0;
4904 int noClasses = objc_getClassList( nullptr, 0 );
4905
4906 Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
4907 objc_getClassList( classes, noClasses );
4908
4909 for( int c = 0; c < noClasses; c++ ) {
4910 Class cls = classes[c];
4911 {
4912 u_int count;
4913 Method* methods = class_copyMethodList( cls, &count );
4914 for( u_int m = 0; m < count ; m++ ) {
4915 SEL selector = method_getName(methods[m]);
4916 std::string methodName = sel_getName(selector);
4917 if( startsWith( methodName, "Catch_TestCase_" ) ) {
4918 std::string testCaseName = methodName.substr( 15 );
4919 std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
4920 std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
4921 const char* className = class_getName( cls );
4922
4923 getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
4924 noTestMethods++;
4925 }
4926 }
4927 free(methods);
4928 }
4929 }
4930 return noTestMethods;
4931 }
4932
4933 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
4934
4935 namespace Matchers {
4936 namespace Impl {
4937 namespace NSStringMatchers {
4938
4939 struct StringHolder : MatcherBase<NSString*>{
4940 StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
4941 StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
4942 StringHolder() {
4943 arcSafeRelease( m_substr );
4944 }
4945
4946 bool match( NSString* str ) const override {
4947 return false;
4948 }
4949
4950 NSString* CATCH_ARC_STRONG m_substr;
4951 };
4952
4953 struct Equals : StringHolder {
4954 Equals( NSString* substr ) : StringHolder( substr ){}
4955
4956 bool match( NSString* str ) const override {
4957 return (str != nil || m_substr == nil ) &&
4958 [str isEqualToString:m_substr];
4959 }
4960
4961 std::string describe() const override {
4962 return "equals string: " + Catch::Detail::stringify( m_substr );
4963 }
4964 };
4965
4966 struct Contains : StringHolder {
4967 Contains( NSString* substr ) : StringHolder( substr ){}
4968
4969 bool match( NSString* str ) const override {
4970 return (str != nil || m_substr == nil ) &&
4971 [str rangeOfString:m_substr].location != NSNotFound;
4972 }
4973
4974 std::string describe() const override {
4975 return "contains string: " + Catch::Detail::stringify( m_substr );
4976 }
4977 };
4978
4979 struct StartsWith : StringHolder {
4980 StartsWith( NSString* substr ) : StringHolder( substr ){}
4981
4982 bool match( NSString* str ) const override {
4983 return (str != nil || m_substr == nil ) &&
4984 [str rangeOfString:m_substr].location == 0;
4985 }
4986
4987 std::string describe() const override {
4988 return "starts with: " + Catch::Detail::stringify( m_substr );
4989 }
4990 };
4991 struct EndsWith : StringHolder {
4992 EndsWith( NSString* substr ) : StringHolder( substr ){}
4993
4994 bool match( NSString* str ) const override {
4995 return (str != nil || m_substr == nil ) &&
4996 [str rangeOfString:m_substr].location == [str length] - [m_substr length];
4997 }
4998
4999 std::string describe() const override {
5000 return "ends with: " + Catch::Detail::stringify( m_substr );
5001 }
5002 };
5003
5004 } // namespace NSStringMatchers
5005 } // namespace Impl
5006
5007 inline Impl::NSStringMatchers::Equals
5008 Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
5009
5010 inline Impl::NSStringMatchers::Contains
5011 Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
5012
5013 inline Impl::NSStringMatchers::StartsWith
5014 StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
5015
5016 inline Impl::NSStringMatchers::EndsWith
5017 EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
5018
5019 } // namespace Matchers
5020
5021 using namespace Matchers;
5022
5023 #endif // CATCH_CONFIG_DISABLE_MATCHERS
5024
5025 } // namespace Catch
5026
5027 ///////////////////////////////////////////////////////////////////////////////
5028 #define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
5029 #define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
5030 +(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
5031 { \
5032 return @ name; \
5033 } \
5034 +(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
5035 { \
5036 return @ desc; \
5037 } \
5038 -(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
5039
5040 #define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
5041
5042 // end catch_objc.hpp
5043 #endif
5044
5045 // Benchmarking needs the externally-facing parts of reporters to work
5046 #if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
5047 // start catch_external_interfaces.h
5048
5049 // start catch_reporter_bases.hpp
5050
5051 // start catch_interfaces_reporter.h
5052
5053 // start catch_config.hpp
5054
5055 // start catch_test_spec_parser.h
5056
5057 #ifdef __clang__
5058 #pragma clang diagnostic push
5059 #pragma clang diagnostic ignored "-Wpadded"
5060 #endif
5061
5062 // start catch_test_spec.h
5063
5064 #ifdef __clang__
5065 #pragma clang diagnostic push
5066 #pragma clang diagnostic ignored "-Wpadded"
5067 #endif
5068
5069 // start catch_wildcard_pattern.h
5070
5071 namespace Catch
5072 {
5073 class WildcardPattern {
5074 enum WildcardPosition {
5075 NoWildcard = 0,
5076 WildcardAtStart = 1,
5077 WildcardAtEnd = 2,
5078 WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
5079 };
5080
5081 public:
5082
5083 WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
5084 virtual ~WildcardPattern() = default;
5085 virtual bool matches( std::string const& str ) const;
5086
5087 private:
5088 std::string normaliseString( std::string const& str ) const;
5089 CaseSensitive::Choice m_caseSensitivity;
5090 WildcardPosition m_wildcard = NoWildcard;
5091 std::string m_pattern;
5092 };
5093 }
5094
5095 // end catch_wildcard_pattern.h
5096 #include <string>
5097 #include <vector>
5098 #include <memory>
5099
5100 namespace Catch {
5101
5102 struct IConfig;
5103
5104 class TestSpec {
5105 class Pattern {
5106 public:
5107 explicit Pattern( std::string const& name );
5108 virtual ~Pattern();
5109 virtual bool matches( TestCaseInfo const& testCase ) const = 0;
5110 std::string const& name() const;
5111 private:
5112 std::string const m_name;
5113 };
5114 using PatternPtr = std::shared_ptr<Pattern>;
5115
5116 class NamePattern : public Pattern {
5117 public:
5118 explicit NamePattern( std::string const& name, std::string const& filterString );
5119 bool matches( TestCaseInfo const& testCase ) const override;
5120 private:
5121 WildcardPattern m_wildcardPattern;
5122 };
5123
5124 class TagPattern : public Pattern {
5125 public:
5126 explicit TagPattern( std::string const& tag, std::string const& filterString );
5127 bool matches( TestCaseInfo const& testCase ) const override;
5128 private:
5129 std::string m_tag;
5130 };
5131
5132 class ExcludedPattern : public Pattern {
5133 public:
5134 explicit ExcludedPattern( PatternPtr const& underlyingPattern );
5135 bool matches( TestCaseInfo const& testCase ) const override;
5136 private:
5137 PatternPtr m_underlyingPattern;
5138 };
5139
5140 struct Filter {
5141 std::vector<PatternPtr> m_patterns;
5142
5143 bool matches( TestCaseInfo const& testCase ) const;
5144 std::string name() const;
5145 };
5146
5147 public:
5148 struct FilterMatch {
5149 std::string name;
5150 std::vector<TestCase const*> tests;
5151 };
5152 using Matches = std::vector<FilterMatch>;
5153 using vectorStrings = std::vector<std::string>;
5154
5155 bool hasFilters() const;
5156 bool matches( TestCaseInfo const& testCase ) const;
5157 Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
5158 const vectorStrings & getInvalidArgs() const;
5159
5160 private:
5161 std::vector<Filter> m_filters;
5162 std::vector<std::string> m_invalidArgs;
5163 friend class TestSpecParser;
5164 };
5165 }
5166
5167 #ifdef __clang__
5168 #pragma clang diagnostic pop
5169 #endif
5170
5171 // end catch_test_spec.h
5172 // start catch_interfaces_tag_alias_registry.h
5173
5174 #include <string>
5175
5176 namespace Catch {
5177
5178 struct TagAlias;
5179
5180 struct ITagAliasRegistry {
5181 virtual ~ITagAliasRegistry();
5182 // Nullptr if not present
5183 virtual TagAlias const* find( std::string const& alias ) const = 0;
5184 virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
5185
5186 static ITagAliasRegistry const& get();
5187 };
5188
5189 } // end namespace Catch
5190
5191 // end catch_interfaces_tag_alias_registry.h
5192 namespace Catch {
5193
5194 class TestSpecParser {
5195 enum Mode{ None, Name, QuotedName, Tag, EscapedName };
5196 Mode m_mode = None;
5197 Mode lastMode = None;
5198 bool m_exclusion = false;
5199 std::size_t m_pos = 0;
5200 std::size_t m_realPatternPos = 0;
5201 std::string m_arg;
5202 std::string m_substring;
5203 std::string m_patternName;
5204 std::vector<std::size_t> m_escapeChars;
5205 TestSpec::Filter m_currentFilter;
5206 TestSpec m_testSpec;
5207 ITagAliasRegistry const* m_tagAliases = nullptr;
5208
5209 public:
5210 TestSpecParser( ITagAliasRegistry const& tagAliases );
5211
5212 TestSpecParser& parse( std::string const& arg );
5213 TestSpec testSpec();
5214
5215 private:
5216 bool visitChar( char c );
5217 void startNewMode( Mode mode );
5218 bool processNoneChar( char c );
5219 void processNameChar( char c );
5220 bool processOtherChar( char c );
5221 void endMode();
5222 void escape();
5223 bool isControlChar( char c ) const;
5224 void saveLastMode();
5225 void revertBackToLastMode();
5226 void addFilter();
5227 bool separate();
5228
5229 // Handles common preprocessing of the pattern for name/tag patterns
5230 std::string preprocessPattern();
5231 // Adds the current pattern as a test name
5232 void addNamePattern();
5233 // Adds the current pattern as a tag
5234 void addTagPattern();
5235
5236 inline void addCharToPattern(char c) {
5237 m_substring += c;
5238 m_patternName += c;
5239 m_realPatternPos++;
5240 }
5241
5242 };
5243 TestSpec parseTestSpec( std::string const& arg );
5244
5245 } // namespace Catch
5246
5247 #ifdef __clang__
5248 #pragma clang diagnostic pop
5249 #endif
5250
5251 // end catch_test_spec_parser.h
5252 // Libstdc++ doesn't like incomplete classes for unique_ptr
5253
5254 #include <memory>
5255 #include <vector>
5256 #include <string>
5257
5258 #ifndef CATCH_CONFIG_CONSOLE_WIDTH
5259 #define CATCH_CONFIG_CONSOLE_WIDTH 80
5260 #endif
5261
5262 namespace Catch {
5263
5264 struct IStream;
5265
5266 struct ConfigData {
5267 bool listTests = false;
5268 bool listTags = false;
5269 bool listReporters = false;
5270 bool listTestNamesOnly = false;
5271
5272 bool showSuccessfulTests = false;
5273 bool shouldDebugBreak = false;
5274 bool noThrow = false;
5275 bool showHelp = false;
5276 bool showInvisibles = false;
5277 bool filenamesAsTags = false;
5278 bool libIdentify = false;
5279
5280 int abortAfter = -1;
5281 unsigned int rngSeed = 0;
5282
5283 bool benchmarkNoAnalysis = false;
5284 unsigned int benchmarkSamples = 100;
5285 double benchmarkConfidenceInterval = 0.95;
5286 unsigned int benchmarkResamples = 100000;
5287 std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
5288
5289 Verbosity verbosity = Verbosity::Normal;
5290 WarnAbout::What warnings = WarnAbout::Nothing;
5291 ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
5292 double minDuration = -1;
5293 RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
5294 UseColour::YesOrNo useColour = UseColour::Auto;
5295 WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
5296
5297 std::string outputFilename;
5298 std::string name;
5299 std::string processName;
5300 #ifndef CATCH_CONFIG_DEFAULT_REPORTER
5301 #define CATCH_CONFIG_DEFAULT_REPORTER "console"
5302 #endif
5303 std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
5304 #undef CATCH_CONFIG_DEFAULT_REPORTER
5305
5306 std::vector<std::string> testsOrTags;
5307 std::vector<std::string> sectionsToRun;
5308 };
5309
5310 class Config : public IConfig {
5311 public:
5312
5313 Config() = default;
5314 Config( ConfigData const& data );
5315 virtual ~Config() = default;
5316
5317 std::string const& getFilename() const;
5318
5319 bool listTests() const;
5320 bool listTestNamesOnly() const;
5321 bool listTags() const;
5322 bool listReporters() const;
5323
5324 std::string getProcessName() const;
5325 std::string const& getReporterName() const;
5326
5327 std::vector<std::string> const& getTestsOrTags() const override;
5328 std::vector<std::string> const& getSectionsToRun() const override;
5329
5330 TestSpec const& testSpec() const override;
5331 bool hasTestFilters() const override;
5332
5333 bool showHelp() const;
5334
5335 // IConfig interface
5336 bool allowThrows() const override;
5337 std::ostream& stream() const override;
5338 std::string name() const override;
5339 bool includeSuccessfulResults() const override;
5340 bool warnAboutMissingAssertions() const override;
5341 bool warnAboutNoTests() const override;
5342 ShowDurations::OrNot showDurations() const override;
5343 double minDuration() const override;
5344 RunTests::InWhatOrder runOrder() const override;
5345 unsigned int rngSeed() const override;
5346 UseColour::YesOrNo useColour() const override;
5347 bool shouldDebugBreak() const override;
5348 int abortAfter() const override;
5349 bool showInvisibles() const override;
5350 Verbosity verbosity() const override;
5351 bool benchmarkNoAnalysis() const override;
5352 int benchmarkSamples() const override;
5353 double benchmarkConfidenceInterval() const override;
5354 unsigned int benchmarkResamples() const override;
5355 std::chrono::milliseconds benchmarkWarmupTime() const override;
5356
5357 private:
5358
5359 IStream const* openStream();
5360 ConfigData m_data;
5361
5362 std::unique_ptr<IStream const> m_stream;
5363 TestSpec m_testSpec;
5364 bool m_hasTestFilters = false;
5365 };
5366
5367 } // end namespace Catch
5368
5369 // end catch_config.hpp
5370 // start catch_assertionresult.h
5371
5372 #include <string>
5373
5374 namespace Catch {
5375
5376 struct AssertionResultData
5377 {
5378 AssertionResultData() = delete;
5379
5380 AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
5381
5382 std::string message;
5383 mutable std::string reconstructedExpression;
5384 LazyExpression lazyExpression;
5385 ResultWas::OfType resultType;
5386
5387 std::string reconstructExpression() const;
5388 };
5389
5390 class AssertionResult {
5391 public:
5392 AssertionResult() = delete;
5393 AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
5394
5395 bool isOk() const;
5396 bool succeeded() const;
5397 ResultWas::OfType getResultType() const;
5398 bool hasExpression() const;
5399 bool hasMessage() const;
5400 std::string getExpression() const;
5401 std::string getExpressionInMacro() const;
5402 bool hasExpandedExpression() const;
5403 std::string getExpandedExpression() const;
5404 std::string getMessage() const;
5405 SourceLineInfo getSourceInfo() const;
5406 StringRef getTestMacroName() const;
5407
5408 //protected:
5409 AssertionInfo m_info;
5410 AssertionResultData m_resultData;
5411 };
5412
5413 } // end namespace Catch
5414
5415 // end catch_assertionresult.h
5416 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
5417 // start catch_estimate.hpp
5418
5419 // Statistics estimates
5420
5421
5422 namespace Catch {
5423 namespace Benchmark {
5424 template <typename Duration>
5425 struct Estimate {
5426 Duration point;
5427 Duration lower_bound;
5428 Duration upper_bound;
5429 double confidence_interval;
5430
5431 template <typename Duration2>
5432 operator Estimate<Duration2>() const {
5433 return { point, lower_bound, upper_bound, confidence_interval };
5434 }
5435 };
5436 } // namespace Benchmark
5437 } // namespace Catch
5438
5439 // end catch_estimate.hpp
5440 // start catch_outlier_classification.hpp
5441
5442 // Outlier information
5443
5444 namespace Catch {
5445 namespace Benchmark {
5446 struct OutlierClassification {
5447 int samples_seen = 0;
5448 int low_severe = 0; // more than 3 times IQR below Q1
5449 int low_mild = 0; // 1.5 to 3 times IQR below Q1
5450 int high_mild = 0; // 1.5 to 3 times IQR above Q3
5451 int high_severe = 0; // more than 3 times IQR above Q3
5452
5453 int total() const {
5454 return low_severe + low_mild + high_mild + high_severe;
5455 }
5456 };
5457 } // namespace Benchmark
5458 } // namespace Catch
5459
5460 // end catch_outlier_classification.hpp
5461 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
5462
5463 #include <string>
5464 #include <iosfwd>
5465 #include <map>
5466 #include <set>
5467 #include <memory>
5468 #include <algorithm>
5469
5470 namespace Catch {
5471
5472 struct ReporterConfig {
5473 explicit ReporterConfig( IConfigPtr const& _fullConfig );
5474
5475 ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
5476
5477 std::ostream& stream() const;
5478 IConfigPtr fullConfig() const;
5479
5480 private:
5481 std::ostream* m_stream;
5482 IConfigPtr m_fullConfig;
5483 };
5484
5485 struct ReporterPreferences {
5486 bool shouldRedirectStdOut = false;
5487 bool shouldReportAllAssertions = false;
5488 };
5489
5490 template<typename T>
5491 struct LazyStat : Option<T> {
5492 LazyStat& operator=( T const& _value ) {
5493 Option<T>::operator=( _value );
5494 used = false;
5495 return *this;
5496 }
5497 void reset() {
5498 Option<T>::reset();
5499 used = false;
5500 }
5501 bool used = false;
5502 };
5503
5504 struct TestRunInfo {
5505 TestRunInfo( std::string const& _name );
5506 std::string name;
5507 };
5508 struct GroupInfo {
5509 GroupInfo( std::string const& _name,
5510 std::size_t _groupIndex,
5511 std::size_t _groupsCount );
5512
5513 std::string name;
5514 std::size_t groupIndex;
5515 std::size_t groupsCounts;
5516 };
5517
5518 struct AssertionStats {
5519 AssertionStats( AssertionResult const& _assertionResult,
5520 std::vector<MessageInfo> const& _infoMessages,
5521 Totals const& _totals );
5522
5523 AssertionStats( AssertionStats const& ) = default;
5524 AssertionStats( AssertionStats && ) = default;
5525 AssertionStats& operator = ( AssertionStats const& ) = delete;
5526 AssertionStats& operator = ( AssertionStats && ) = delete;
5527 virtual ~AssertionStats();
5528
5529 AssertionResult assertionResult;
5530 std::vector<MessageInfo> infoMessages;
5531 Totals totals;
5532 };
5533
5534 struct SectionStats {
5535 SectionStats( SectionInfo const& _sectionInfo,
5536 Counts const& _assertions,
5537 double _durationInSeconds,
5538 bool _missingAssertions );
5539 SectionStats( SectionStats const& ) = default;
5540 SectionStats( SectionStats && ) = default;
5541 SectionStats& operator = ( SectionStats const& ) = default;
5542 SectionStats& operator = ( SectionStats && ) = default;
5543 virtual ~SectionStats();
5544
5545 SectionInfo sectionInfo;
5546 Counts assertions;
5547 double durationInSeconds;
5548 bool missingAssertions;
5549 };
5550
5551 struct TestCaseStats {
5552 TestCaseStats( TestCaseInfo const& _testInfo,
5553 Totals const& _totals,
5554 std::string const& _stdOut,
5555 std::string const& _stdErr,
5556 bool _aborting );
5557
5558 TestCaseStats( TestCaseStats const& ) = default;
5559 TestCaseStats( TestCaseStats && ) = default;
5560 TestCaseStats& operator = ( TestCaseStats const& ) = default;
5561 TestCaseStats& operator = ( TestCaseStats && ) = default;
5562 virtual ~TestCaseStats();
5563
5564 TestCaseInfo testInfo;
5565 Totals totals;
5566 std::string stdOut;
5567 std::string stdErr;
5568 bool aborting;
5569 };
5570
5571 struct TestGroupStats {
5572 TestGroupStats( GroupInfo const& _groupInfo,
5573 Totals const& _totals,
5574 bool _aborting );
5575 TestGroupStats( GroupInfo const& _groupInfo );
5576
5577 TestGroupStats( TestGroupStats const& ) = default;
5578 TestGroupStats( TestGroupStats && ) = default;
5579 TestGroupStats& operator = ( TestGroupStats const& ) = default;
5580 TestGroupStats& operator = ( TestGroupStats && ) = default;
5581 virtual ~TestGroupStats();
5582
5583 GroupInfo groupInfo;
5584 Totals totals;
5585 bool aborting;
5586 };
5587
5588 struct TestRunStats {
5589 TestRunStats( TestRunInfo const& _runInfo,
5590 Totals const& _totals,
5591 bool _aborting );
5592
5593 TestRunStats( TestRunStats const& ) = default;
5594 TestRunStats( TestRunStats && ) = default;
5595 TestRunStats& operator = ( TestRunStats const& ) = default;
5596 TestRunStats& operator = ( TestRunStats && ) = default;
5597 virtual ~TestRunStats();
5598
5599 TestRunInfo runInfo;
5600 Totals totals;
5601 bool aborting;
5602 };
5603
5604 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
5605 struct BenchmarkInfo {
5606 std::string name;
5607 double estimatedDuration;
5608 int iterations;
5609 int samples;
5610 unsigned int resamples;
5611 double clockResolution;
5612 double clockCost;
5613 };
5614
5615 template <class Duration>
5616 struct BenchmarkStats {
5617 BenchmarkInfo info;
5618
5619 std::vector<Duration> samples;
5620 Benchmark::Estimate<Duration> mean;
5621 Benchmark::Estimate<Duration> standardDeviation;
5622 Benchmark::OutlierClassification outliers;
5623 double outlierVariance;
5624
5625 template <typename Duration2>
5626 operator BenchmarkStats<Duration2>() const {
5627 std::vector<Duration2> samples2;
5628 samples2.reserve(samples.size());
5629 std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
5630 return {
5631 info,
5632 std::move(samples2),
5633 mean,
5634 standardDeviation,
5635 outliers,
5636 outlierVariance,
5637 };
5638 }
5639 };
5640 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
5641
5642 struct IStreamingReporter {
5643 virtual ~IStreamingReporter() = default;
5644
5645 // Implementing class must also provide the following static methods:
5646 // static std::string getDescription();
5647 // static std::set<Verbosity> getSupportedVerbosities()
5648
5649 virtual ReporterPreferences getPreferences() const = 0;
5650
5651 virtual void noMatchingTestCases( std::string const& spec ) = 0;
5652
5653 virtual void reportInvalidArguments(std::string const&) {}
5654
5655 virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
5656 virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
5657
5658 virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
5659 virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
5660
5661 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
5662 virtual void benchmarkPreparing( std::string const& ) {}
5663 virtual void benchmarkStarting( BenchmarkInfo const& ) {}
5664 virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
5665 virtual void benchmarkFailed( std::string const& ) {}
5666 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
5667
5668 virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
5669
5670 // The return value indicates if the messages buffer should be cleared:
5671 virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
5672
5673 virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
5674 virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
5675 virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
5676 virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
5677
5678 virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
5679
5680 // Default empty implementation provided
5681 virtual void fatalErrorEncountered( StringRef name );
5682
5683 virtual bool isMulti() const;
5684 };
5685 using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
5686
5687 struct IReporterFactory {
5688 virtual ~IReporterFactory();
5689 virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
5690 virtual std::string getDescription() const = 0;
5691 };
5692 using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
5693
5694 struct IReporterRegistry {
5695 using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
5696 using Listeners = std::vector<IReporterFactoryPtr>;
5697
5698 virtual ~IReporterRegistry();
5699 virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
5700 virtual FactoryMap const& getFactories() const = 0;
5701 virtual Listeners const& getListeners() const = 0;
5702 };
5703
5704 } // end namespace Catch
5705
5706 // end catch_interfaces_reporter.h
5707 #include <algorithm>
5708 #include <cstring>
5709 #include <cfloat>
5710 #include <cstdio>
5711 #include <cassert>
5712 #include <memory>
5713 #include <ostream>
5714
5715 namespace Catch {
5716 void prepareExpandedExpression(AssertionResult& result);
5717
5718 // Returns double formatted as %.3f (format expected on output)
5719 std::string getFormattedDuration( double duration );
5720
5721 //! Should the reporter show
5722 bool shouldShowDuration( IConfig const& config, double duration );
5723
5724 std::string serializeFilters( std::vector<std::string> const& container );
5725
5726 template<typename DerivedT>
5727 struct StreamingReporterBase : IStreamingReporter {
5728
5729 StreamingReporterBase( ReporterConfig const& _config )
5730 : m_config( _config.fullConfig() ),
5731 stream( _config.stream() )
5732 {
5733 m_reporterPrefs.shouldRedirectStdOut = false;
5734 if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
5735 CATCH_ERROR( "Verbosity level not supported by this reporter" );
5736 }
5737
5738 ReporterPreferences getPreferences() const override {
5739 return m_reporterPrefs;
5740 }
5741
5742 static std::set<Verbosity> getSupportedVerbosities() {
5743 return { Verbosity::Normal };
5744 }
5745
5746 ~StreamingReporterBase() override = default;
5747
5748 void noMatchingTestCases(std::string const&) override {}
5749
5750 void reportInvalidArguments(std::string const&) override {}
5751
5752 void testRunStarting(TestRunInfo const& _testRunInfo) override {
5753 currentTestRunInfo = _testRunInfo;
5754 }
5755
5756 void testGroupStarting(GroupInfo const& _groupInfo) override {
5757 currentGroupInfo = _groupInfo;
5758 }
5759
5760 void testCaseStarting(TestCaseInfo const& _testInfo) override {
5761 currentTestCaseInfo = _testInfo;
5762 }
5763 void sectionStarting(SectionInfo const& _sectionInfo) override {
5764 m_sectionStack.push_back(_sectionInfo);
5765 }
5766
5767 void sectionEnded(SectionStats const& /* _sectionStats */) override {
5768 m_sectionStack.pop_back();
5769 }
5770 void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
5771 currentTestCaseInfo.reset();
5772 }
5773 void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
5774 currentGroupInfo.reset();
5775 }
5776 void testRunEnded(TestRunStats const& /* _testRunStats */) override {
5777 currentTestCaseInfo.reset();
5778 currentGroupInfo.reset();
5779 currentTestRunInfo.reset();
5780 }
5781
5782 void skipTest(TestCaseInfo const&) override {
5783 // Don't do anything with this by default.
5784 // It can optionally be overridden in the derived class.
5785 }
5786
5787 IConfigPtr m_config;
5788 std::ostream& stream;
5789
5790 LazyStat<TestRunInfo> currentTestRunInfo;
5791 LazyStat<GroupInfo> currentGroupInfo;
5792 LazyStat<TestCaseInfo> currentTestCaseInfo;
5793
5794 std::vector<SectionInfo> m_sectionStack;
5795 ReporterPreferences m_reporterPrefs;
5796 };
5797
5798 template<typename DerivedT>
5799 struct CumulativeReporterBase : IStreamingReporter {
5800 template<typename T, typename ChildNodeT>
5801 struct Node {
5802 explicit Node( T const& _value ) : value( _value ) {}
5803 virtual ~Node() {}
5804
5805 using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
5806 T value;
5807 ChildNodes children;
5808 };
5809 struct SectionNode {
5810 explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
5811 virtual ~SectionNode() = default;
5812
5813 bool operator == (SectionNode const& other) const {
5814 return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
5815 }
5816 bool operator == (std::shared_ptr<SectionNode> const& other) const {
5817 return operator==(*other);
5818 }
5819
5820 SectionStats stats;
5821 using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
5822 using Assertions = std::vector<AssertionStats>;
5823 ChildSections childSections;
5824 Assertions assertions;
5825 std::string stdOut;
5826 std::string stdErr;
5827 };
5828
5829 struct BySectionInfo {
5830 BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
5831 BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
5832 bool operator() (std::shared_ptr<SectionNode> const& node) const {
5833 return ((node->stats.sectionInfo.name == m_other.name) &&
5834 (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
5835 }
5836 void operator=(BySectionInfo const&) = delete;
5837
5838 private:
5839 SectionInfo const& m_other;
5840 };
5841
5842 using TestCaseNode = Node<TestCaseStats, SectionNode>;
5843 using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
5844 using TestRunNode = Node<TestRunStats, TestGroupNode>;
5845
5846 CumulativeReporterBase( ReporterConfig const& _config )
5847 : m_config( _config.fullConfig() ),
5848 stream( _config.stream() )
5849 {
5850 m_reporterPrefs.shouldRedirectStdOut = false;
5851 if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
5852 CATCH_ERROR( "Verbosity level not supported by this reporter" );
5853 }
5854 ~CumulativeReporterBase() override = default;
5855
5856 ReporterPreferences getPreferences() const override {
5857 return m_reporterPrefs;
5858 }
5859
5860 static std::set<Verbosity> getSupportedVerbosities() {
5861 return { Verbosity::Normal };
5862 }
5863
5864 void testRunStarting( TestRunInfo const& ) override {}
5865 void testGroupStarting( GroupInfo const& ) override {}
5866
5867 void testCaseStarting( TestCaseInfo const& ) override {}
5868
5869 void sectionStarting( SectionInfo const& sectionInfo ) override {
5870 SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
5871 std::shared_ptr<SectionNode> node;
5872 if( m_sectionStack.empty() ) {
5873 if( !m_rootSection )
5874 m_rootSection = std::make_shared<SectionNode>( incompleteStats );
5875 node = m_rootSection;
5876 }
5877 else {
5878 SectionNode& parentNode = *m_sectionStack.back();
5879 auto it =
5880 std::find_if( parentNode.childSections.begin(),
5881 parentNode.childSections.end(),
5882 BySectionInfo( sectionInfo ) );
5883 if( it == parentNode.childSections.end() ) {
5884 node = std::make_shared<SectionNode>( incompleteStats );
5885 parentNode.childSections.push_back( node );
5886 }
5887 else
5888 node = *it;
5889 }
5890 m_sectionStack.push_back( node );
5891 m_deepestSection = std::move(node);
5892 }
5893
5894 void assertionStarting(AssertionInfo const&) override {}
5895
5896 bool assertionEnded(AssertionStats const& assertionStats) override {
5897 assert(!m_sectionStack.empty());
5898 // AssertionResult holds a pointer to a temporary DecomposedExpression,
5899 // which getExpandedExpression() calls to build the expression string.
5900 // Our section stack copy of the assertionResult will likely outlive the
5901 // temporary, so it must be expanded or discarded now to avoid calling
5902 // a destroyed object later.
5903 prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
5904 SectionNode& sectionNode = *m_sectionStack.back();
5905 sectionNode.assertions.push_back(assertionStats);
5906 return true;
5907 }
5908 void sectionEnded(SectionStats const& sectionStats) override {
5909 assert(!m_sectionStack.empty());
5910 SectionNode& node = *m_sectionStack.back();
5911 node.stats = sectionStats;
5912 m_sectionStack.pop_back();
5913 }
5914 void testCaseEnded(TestCaseStats const& testCaseStats) override {
5915 auto node = std::make_shared<TestCaseNode>(testCaseStats);
5916 assert(m_sectionStack.size() == 0);
5917 node->children.push_back(m_rootSection);
5918 m_testCases.push_back(node);
5919 m_rootSection.reset();
5920
5921 assert(m_deepestSection);
5922 m_deepestSection->stdOut = testCaseStats.stdOut;
5923 m_deepestSection->stdErr = testCaseStats.stdErr;
5924 }
5925 void testGroupEnded(TestGroupStats const& testGroupStats) override {
5926 auto node = std::make_shared<TestGroupNode>(testGroupStats);
5927 node->children.swap(m_testCases);
5928 m_testGroups.push_back(node);
5929 }
5930 void testRunEnded(TestRunStats const& testRunStats) override {
5931 auto node = std::make_shared<TestRunNode>(testRunStats);
5932 node->children.swap(m_testGroups);
5933 m_testRuns.push_back(node);
5934 testRunEndedCumulative();
5935 }
5936 virtual void testRunEndedCumulative() = 0;
5937
5938 void skipTest(TestCaseInfo const&) override {}
5939
5940 IConfigPtr m_config;
5941 std::ostream& stream;
5942 std::vector<AssertionStats> m_assertions;
5943 std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
5944 std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
5945 std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
5946
5947 std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
5948
5949 std::shared_ptr<SectionNode> m_rootSection;
5950 std::shared_ptr<SectionNode> m_deepestSection;
5951 std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
5952 ReporterPreferences m_reporterPrefs;
5953 };
5954
5955 template<char C>
5956 char const* getLineOfChars() {
5957 static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
5958 if( !*line ) {
5959 std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
5960 line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
5961 }
5962 return line;
5963 }
5964
5965 struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
5966 TestEventListenerBase( ReporterConfig const& _config );
5967
5968 static std::set<Verbosity> getSupportedVerbosities();
5969
5970 void assertionStarting(AssertionInfo const&) override;
5971 bool assertionEnded(AssertionStats const&) override;
5972 };
5973
5974 } // end namespace Catch
5975
5976 // end catch_reporter_bases.hpp
5977 // start catch_console_colour.h
5978
5979 namespace Catch {
5980
5981 struct Colour {
5982 enum Code {
5983 None = 0,
5984
5985 White,
5986 Red,
5987 Green,
5988 Blue,
5989 Cyan,
5990 Yellow,
5991 Grey,
5992
5993 Bright = 0x10,
5994
5995 BrightRed = Bright | Red,
5996 BrightGreen = Bright | Green,
5997 LightGrey = Bright | Grey,
5998 BrightWhite = Bright | White,
5999 BrightYellow = Bright | Yellow,
6000
6001 // By intention
6002 FileName = LightGrey,
6003 Warning = BrightYellow,
6004 ResultError = BrightRed,
6005 ResultSuccess = BrightGreen,
6006 ResultExpectedFailure = Warning,
6007
6008 Error = BrightRed,
6009 Success = Green,
6010
6011 OriginalExpression = Cyan,
6012 ReconstructedExpression = BrightYellow,
6013
6014 SecondaryText = LightGrey,
6015 Headers = White
6016 };
6017
6018 // Use constructed object for RAII guard
6019 Colour( Code _colourCode );
6020 Colour( Colour&& other ) noexcept;
6021 Colour& operator=( Colour&& other ) noexcept;
6022 ~Colour();
6023
6024 // Use static method for one-shot changes
6025 static void use( Code _colourCode );
6026
6027 private:
6028 bool m_moved = false;
6029 };
6030
6031 std::ostream& operator << ( std::ostream& os, Colour const& );
6032
6033 } // end namespace Catch
6034
6035 // end catch_console_colour.h
6036 // start catch_reporter_registrars.hpp
6037
6038
6039 namespace Catch {
6040
6041 template<typename T>
6042 class ReporterRegistrar {
6043
6044 class ReporterFactory : public IReporterFactory {
6045
6046 IStreamingReporterPtr create( ReporterConfig const& config ) const override {
6047 return std::unique_ptr<T>( new T( config ) );
6048 }
6049
6050 std::string getDescription() const override {
6051 return T::getDescription();
6052 }
6053 };
6054
6055 public:
6056
6057 explicit ReporterRegistrar( std::string const& name ) {
6058 getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
6059 }
6060 };
6061
6062 template<typename T>
6063 class ListenerRegistrar {
6064
6065 class ListenerFactory : public IReporterFactory {
6066
6067 IStreamingReporterPtr create( ReporterConfig const& config ) const override {
6068 return std::unique_ptr<T>( new T( config ) );
6069 }
6070 std::string getDescription() const override {
6071 return std::string();
6072 }
6073 };
6074
6075 public:
6076
6077 ListenerRegistrar() {
6078 getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
6079 }
6080 };
6081 }
6082
6083 #if !defined(CATCH_CONFIG_DISABLE)
6084
6085 #define CATCH_REGISTER_REPORTER( name, reporterType ) \
6086 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
6087 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
6088 namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
6089 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
6090
6091 #define CATCH_REGISTER_LISTENER( listenerType ) \
6092 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
6093 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
6094 namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
6095 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
6096 #else // CATCH_CONFIG_DISABLE
6097
6098 #define CATCH_REGISTER_REPORTER(name, reporterType)
6099 #define CATCH_REGISTER_LISTENER(listenerType)
6100
6101 #endif // CATCH_CONFIG_DISABLE
6102
6103 // end catch_reporter_registrars.hpp
6104 // Allow users to base their work off existing reporters
6105 // start catch_reporter_compact.h
6106
6107 namespace Catch {
6108
6109 struct CompactReporter : StreamingReporterBase<CompactReporter> {
6110
6111 using StreamingReporterBase::StreamingReporterBase;
6112
6113 ~CompactReporter() override;
6114
6115 static std::string getDescription();
6116
6117 void noMatchingTestCases(std::string const& spec) override;
6118
6119 void assertionStarting(AssertionInfo const&) override;
6120
6121 bool assertionEnded(AssertionStats const& _assertionStats) override;
6122
6123 void sectionEnded(SectionStats const& _sectionStats) override;
6124
6125 void testRunEnded(TestRunStats const& _testRunStats) override;
6126
6127 };
6128
6129 } // end namespace Catch
6130
6131 // end catch_reporter_compact.h
6132 // start catch_reporter_console.h
6133
6134 #if defined(_MSC_VER)
6135 #pragma warning(push)
6136 #pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
6137 // Note that 4062 (not all labels are handled
6138 // and default is missing) is enabled
6139 #endif
6140
6141 namespace Catch {
6142 // Fwd decls
6143 struct SummaryColumn;
6144 class TablePrinter;
6145
6146 struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
6147 std::unique_ptr<TablePrinter> m_tablePrinter;
6148
6149 ConsoleReporter(ReporterConfig const& config);
6150 ~ConsoleReporter() override;
6151 static std::string getDescription();
6152
6153 void noMatchingTestCases(std::string const& spec) override;
6154
6155 void reportInvalidArguments(std::string const&arg) override;
6156
6157 void assertionStarting(AssertionInfo const&) override;
6158
6159 bool assertionEnded(AssertionStats const& _assertionStats) override;
6160
6161 void sectionStarting(SectionInfo const& _sectionInfo) override;
6162 void sectionEnded(SectionStats const& _sectionStats) override;
6163
6164 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
6165 void benchmarkPreparing(std::string const& name) override;
6166 void benchmarkStarting(BenchmarkInfo const& info) override;
6167 void benchmarkEnded(BenchmarkStats<> const& stats) override;
6168 void benchmarkFailed(std::string const& error) override;
6169 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
6170
6171 void testCaseEnded(TestCaseStats const& _testCaseStats) override;
6172 void testGroupEnded(TestGroupStats const& _testGroupStats) override;
6173 void testRunEnded(TestRunStats const& _testRunStats) override;
6174 void testRunStarting(TestRunInfo const& _testRunInfo) override;
6175 private:
6176
6177 void lazyPrint();
6178
6179 void lazyPrintWithoutClosingBenchmarkTable();
6180 void lazyPrintRunInfo();
6181 void lazyPrintGroupInfo();
6182 void printTestCaseAndSectionHeader();
6183
6184 void printClosedHeader(std::string const& _name);
6185 void printOpenHeader(std::string const& _name);
6186
6187 // if string has a : in first line will set indent to follow it on
6188 // subsequent lines
6189 void printHeaderString(std::string const& _string, std::size_t indent = 0);
6190
6191 void printTotals(Totals const& totals);
6192 void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
6193
6194 void printTotalsDivider(Totals const& totals);
6195 void printSummaryDivider();
6196 void printTestFilters();
6197
6198 private:
6199 bool m_headerPrinted = false;
6200 };
6201
6202 } // end namespace Catch
6203
6204 #if defined(_MSC_VER)
6205 #pragma warning(pop)
6206 #endif
6207
6208 // end catch_reporter_console.h
6209 // start catch_reporter_junit.h
6210
6211 // start catch_xmlwriter.h
6212
6213 #include <vector>
6214
6215 namespace Catch {
6216 enum class XmlFormatting {
6217 None = 0x00,
6218 Indent = 0x01,
6219 Newline = 0x02,
6220 };
6221
6222 XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
6223 XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
6224
6225 class XmlEncode {
6226 public:
6227 enum ForWhat { ForTextNodes, ForAttributes };
6228
6229 XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
6230
6231 void encodeTo( std::ostream& os ) const;
6232
6233 friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
6234
6235 private:
6236 std::string m_str;
6237 ForWhat m_forWhat;
6238 };
6239
6240 class XmlWriter {
6241 public:
6242
6243 class ScopedElement {
6244 public:
6245 ScopedElement( XmlWriter* writer, XmlFormatting fmt );
6246
6247 ScopedElement( ScopedElement&& other ) noexcept;
6248 ScopedElement& operator=( ScopedElement&& other ) noexcept;
6249
6250 ~ScopedElement();
6251
6252 ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
6253
6254 template<typename T>
6255 ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
6256 m_writer->writeAttribute( name, attribute );
6257 return *this;
6258 }
6259
6260 private:
6261 mutable XmlWriter* m_writer = nullptr;
6262 XmlFormatting m_fmt;
6263 };
6264
6265 XmlWriter( std::ostream& os = Catch::cout() );
6266 ~XmlWriter();
6267
6268 XmlWriter( XmlWriter const& ) = delete;
6269 XmlWriter& operator=( XmlWriter const& ) = delete;
6270
6271 XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
6272
6273 ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
6274
6275 XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
6276
6277 XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
6278
6279 XmlWriter& writeAttribute( std::string const& name, bool attribute );
6280
6281 template<typename T>
6282 XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
6283 ReusableStringStream rss;
6284 rss << attribute;
6285 return writeAttribute( name, rss.str() );
6286 }
6287
6288 XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
6289
6290 XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
6291
6292 void writeStylesheetRef( std::string const& url );
6293
6294 XmlWriter& writeBlankLine();
6295
6296 void ensureTagClosed();
6297
6298 private:
6299
6300 void applyFormatting(XmlFormatting fmt);
6301
6302 void writeDeclaration();
6303
6304 void newlineIfNecessary();
6305
6306 bool m_tagIsOpen = false;
6307 bool m_needsNewline = false;
6308 std::vector<std::string> m_tags;
6309 std::string m_indent;
6310 std::ostream& m_os;
6311 };
6312
6313 }
6314
6315 // end catch_xmlwriter.h
6316 namespace Catch {
6317
6318 class JunitReporter : public CumulativeReporterBase<JunitReporter> {
6319 public:
6320 JunitReporter(ReporterConfig const& _config);
6321
6322 ~JunitReporter() override;
6323
6324 static std::string getDescription();
6325
6326 void noMatchingTestCases(std::string const& /*spec*/) override;
6327
6328 void testRunStarting(TestRunInfo const& runInfo) override;
6329
6330 void testGroupStarting(GroupInfo const& groupInfo) override;
6331
6332 void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
6333 bool assertionEnded(AssertionStats const& assertionStats) override;
6334
6335 void testCaseEnded(TestCaseStats const& testCaseStats) override;
6336
6337 void testGroupEnded(TestGroupStats const& testGroupStats) override;
6338
6339 void testRunEndedCumulative() override;
6340
6341 void writeGroup(TestGroupNode const& groupNode, double suiteTime);
6342
6343 void writeTestCase(TestCaseNode const& testCaseNode);
6344
6345 void writeSection(std::string const& className,
6346 std::string const& rootName,
6347 SectionNode const& sectionNode);
6348
6349 void writeAssertions(SectionNode const& sectionNode);
6350 void writeAssertion(AssertionStats const& stats);
6351
6352 XmlWriter xml;
6353 Timer suiteTimer;
6354 std::string stdOutForSuite;
6355 std::string stdErrForSuite;
6356 unsigned int unexpectedExceptions = 0;
6357 bool m_okToFail = false;
6358 };
6359
6360 } // end namespace Catch
6361
6362 // end catch_reporter_junit.h
6363 // start catch_reporter_xml.h
6364
6365 namespace Catch {
6366 class XmlReporter : public StreamingReporterBase<XmlReporter> {
6367 public:
6368 XmlReporter(ReporterConfig const& _config);
6369
6370 ~XmlReporter() override;
6371
6372 static std::string getDescription();
6373
6374 virtual std::string getStylesheetRef() const;
6375
6376 void writeSourceInfo(SourceLineInfo const& sourceInfo);
6377
6378 public: // StreamingReporterBase
6379
6380 void noMatchingTestCases(std::string const& s) override;
6381
6382 void testRunStarting(TestRunInfo const& testInfo) override;
6383
6384 void testGroupStarting(GroupInfo const& groupInfo) override;
6385
6386 void testCaseStarting(TestCaseInfo const& testInfo) override;
6387
6388 void sectionStarting(SectionInfo const& sectionInfo) override;
6389
6390 void assertionStarting(AssertionInfo const&) override;
6391
6392 bool assertionEnded(AssertionStats const& assertionStats) override;
6393
6394 void sectionEnded(SectionStats const& sectionStats) override;
6395
6396 void testCaseEnded(TestCaseStats const& testCaseStats) override;
6397
6398 void testGroupEnded(TestGroupStats const& testGroupStats) override;
6399
6400 void testRunEnded(TestRunStats const& testRunStats) override;
6401
6402 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
6403 void benchmarkPreparing(std::string const& name) override;
6404 void benchmarkStarting(BenchmarkInfo const&) override;
6405 void benchmarkEnded(BenchmarkStats<> const&) override;
6406 void benchmarkFailed(std::string const&) override;
6407 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
6408
6409 private:
6410 Timer m_testCaseTimer;
6411 XmlWriter m_xml;
6412 int m_sectionDepth = 0;
6413 };
6414
6415 } // end namespace Catch
6416
6417 // end catch_reporter_xml.h
6418
6419 // end catch_external_interfaces.h
6420 #endif
6421
6422 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
6423 // start catch_benchmarking_all.hpp
6424
6425 // A proxy header that includes all of the benchmarking headers to allow
6426 // concise include of the benchmarking features. You should prefer the
6427 // individual includes in standard use.
6428
6429 // start catch_benchmark.hpp
6430
6431 // Benchmark
6432
6433 // start catch_chronometer.hpp
6434
6435 // User-facing chronometer
6436
6437
6438 // start catch_clock.hpp
6439
6440 // Clocks
6441
6442
6443 #include <chrono>
6444 #include <ratio>
6445
6446 namespace Catch {
6447 namespace Benchmark {
6448 template <typename Clock>
6449 using ClockDuration = typename Clock::duration;
6450 template <typename Clock>
6451 using FloatDuration = std::chrono::duration<double, typename Clock::period>;
6452
6453 template <typename Clock>
6454 using TimePoint = typename Clock::time_point;
6455
6456 using default_clock = std::chrono::steady_clock;
6457
6458 template <typename Clock>
6459 struct now {
6460 TimePoint<Clock> operator()() const {
6461 return Clock::now();
6462 }
6463 };
6464
6465 using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
6466 } // namespace Benchmark
6467 } // namespace Catch
6468
6469 // end catch_clock.hpp
6470 // start catch_optimizer.hpp
6471
6472 // Hinting the optimizer
6473
6474
6475 #if defined(_MSC_VER)
6476 # include <atomic> // atomic_thread_fence
6477 #endif
6478
6479 namespace Catch {
6480 namespace Benchmark {
6481 #if defined(__GNUC__) || defined(__clang__)
6482 template <typename T>
6483 inline void keep_memory(T* p) {
6484 asm volatile("" : : "g"(p) : "memory");
6485 }
6486 inline void keep_memory() {
6487 asm volatile("" : : : "memory");
6488 }
6489
6490 namespace Detail {
6491 inline void optimizer_barrier() { keep_memory(); }
6492 } // namespace Detail
6493 #elif defined(_MSC_VER)
6494
6495 #pragma optimize("", off)
6496 template <typename T>
6497 inline void keep_memory(T* p) {
6498 // thanks @milleniumbug
6499 *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
6500 }
6501 // TODO equivalent keep_memory()
6502 #pragma optimize("", on)
6503
6504 namespace Detail {
6505 inline void optimizer_barrier() {
6506 std::atomic_thread_fence(std::memory_order_seq_cst);
6507 }
6508 } // namespace Detail
6509
6510 #endif
6511
6512 template <typename T>
6513 inline void deoptimize_value(T&& x) {
6514 keep_memory(&x);
6515 }
6516
6517 template <typename Fn, typename... Args>
6518 inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
6519 deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
6520 }
6521
6522 template <typename Fn, typename... Args>
6523 inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
6524 std::forward<Fn>(fn) (std::forward<Args...>(args...));
6525 }
6526 } // namespace Benchmark
6527 } // namespace Catch
6528
6529 // end catch_optimizer.hpp
6530 // start catch_complete_invoke.hpp
6531
6532 // Invoke with a special case for void
6533
6534
6535 #include <type_traits>
6536 #include <utility>
6537
6538 namespace Catch {
6539 namespace Benchmark {
6540 namespace Detail {
6541 template <typename T>
6542 struct CompleteType { using type = T; };
6543 template <>
6544 struct CompleteType<void> { struct type {}; };
6545
6546 template <typename T>
6547 using CompleteType_t = typename CompleteType<T>::type;
6548
6549 template <typename Result>
6550 struct CompleteInvoker {
6551 template <typename Fun, typename... Args>
6552 static Result invoke(Fun&& fun, Args&&... args) {
6553 return std::forward<Fun>(fun)(std::forward<Args>(args)...);
6554 }
6555 };
6556 template <>
6557 struct CompleteInvoker<void> {
6558 template <typename Fun, typename... Args>
6559 static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
6560 std::forward<Fun>(fun)(std::forward<Args>(args)...);
6561 return {};
6562 }
6563 };
6564
6565 // invoke and not return void :(
6566 template <typename Fun, typename... Args>
6567 CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
6568 return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
6569 }
6570
6571 const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
6572 } // namespace Detail
6573
6574 template <typename Fun>
6575 Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
6576 CATCH_TRY{
6577 return Detail::complete_invoke(std::forward<Fun>(fun));
6578 } CATCH_CATCH_ALL{
6579 getResultCapture().benchmarkFailed(translateActiveException());
6580 CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
6581 }
6582 }
6583 } // namespace Benchmark
6584 } // namespace Catch
6585
6586 // end catch_complete_invoke.hpp
6587 namespace Catch {
6588 namespace Benchmark {
6589 namespace Detail {
6590 struct ChronometerConcept {
6591 virtual void start() = 0;
6592 virtual void finish() = 0;
6593 virtual ~ChronometerConcept() = default;
6594 };
6595 template <typename Clock>
6596 struct ChronometerModel final : public ChronometerConcept {
6597 void start() override { started = Clock::now(); }
6598 void finish() override { finished = Clock::now(); }
6599
6600 ClockDuration<Clock> elapsed() const { return finished - started; }
6601
6602 TimePoint<Clock> started;
6603 TimePoint<Clock> finished;
6604 };
6605 } // namespace Detail
6606
6607 struct Chronometer {
6608 public:
6609 template <typename Fun>
6610 void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
6611
6612 int runs() const { return k; }
6613
6614 Chronometer(Detail::ChronometerConcept& meter, int k)
6615 : impl(&meter)
6616 , k(k) {}
6617
6618 private:
6619 template <typename Fun>
6620 void measure(Fun&& fun, std::false_type) {
6621 measure([&fun](int) { return fun(); }, std::true_type());
6622 }
6623
6624 template <typename Fun>
6625 void measure(Fun&& fun, std::true_type) {
6626 Detail::optimizer_barrier();
6627 impl->start();
6628 for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
6629 impl->finish();
6630 Detail::optimizer_barrier();
6631 }
6632
6633 Detail::ChronometerConcept* impl;
6634 int k;
6635 };
6636 } // namespace Benchmark
6637 } // namespace Catch
6638
6639 // end catch_chronometer.hpp
6640 // start catch_environment.hpp
6641
6642 // Environment information
6643
6644
6645 namespace Catch {
6646 namespace Benchmark {
6647 template <typename Duration>
6648 struct EnvironmentEstimate {
6649 Duration mean;
6650 OutlierClassification outliers;
6651
6652 template <typename Duration2>
6653 operator EnvironmentEstimate<Duration2>() const {
6654 return { mean, outliers };
6655 }
6656 };
6657 template <typename Clock>
6658 struct Environment {
6659 using clock_type = Clock;
6660 EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
6661 EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
6662 };
6663 } // namespace Benchmark
6664 } // namespace Catch
6665
6666 // end catch_environment.hpp
6667 // start catch_execution_plan.hpp
6668
6669 // Execution plan
6670
6671
6672 // start catch_benchmark_function.hpp
6673
6674 // Dumb std::function implementation for consistent call overhead
6675
6676
6677 #include <cassert>
6678 #include <type_traits>
6679 #include <utility>
6680 #include <memory>
6681
6682 namespace Catch {
6683 namespace Benchmark {
6684 namespace Detail {
6685 template <typename T>
6686 using Decay = typename std::decay<T>::type;
6687 template <typename T, typename U>
6688 struct is_related
6689 : std::is_same<Decay<T>, Decay<U>> {};
6690
6691 /// We need to reinvent std::function because every piece of code that might add overhead
6692 /// in a measurement context needs to have consistent performance characteristics so that we
6693 /// can account for it in the measurement.
6694 /// Implementations of std::function with optimizations that aren't always applicable, like
6695 /// small buffer optimizations, are not uncommon.
6696 /// This is effectively an implementation of std::function without any such optimizations;
6697 /// it may be slow, but it is consistently slow.
6698 struct BenchmarkFunction {
6699 private:
6700 struct callable {
6701 virtual void call(Chronometer meter) const = 0;
6702 virtual callable* clone() const = 0;
6703 virtual ~callable() = default;
6704 };
6705 template <typename Fun>
6706 struct model : public callable {
6707 model(Fun&& fun) : fun(std::move(fun)) {}
6708 model(Fun const& fun) : fun(fun) {}
6709
6710 model<Fun>* clone() const override { return new model<Fun>(*this); }
6711
6712 void call(Chronometer meter) const override {
6713 call(meter, is_callable<Fun(Chronometer)>());
6714 }
6715 void call(Chronometer meter, std::true_type) const {
6716 fun(meter);
6717 }
6718 void call(Chronometer meter, std::false_type) const {
6719 meter.measure(fun);
6720 }
6721
6722 Fun fun;
6723 };
6724
6725 struct do_nothing { void operator()() const {} };
6726
6727 template <typename T>
6728 BenchmarkFunction(model<T>* c) : f(c) {}
6729
6730 public:
6731 BenchmarkFunction()
6732 : f(new model<do_nothing>{ {} }) {}
6733
6734 template <typename Fun,
6735 typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
6736 BenchmarkFunction(Fun&& fun)
6737 : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
6738
6739 BenchmarkFunction(BenchmarkFunction&& that)
6740 : f(std::move(that.f)) {}
6741
6742 BenchmarkFunction(BenchmarkFunction const& that)
6743 : f(that.f->clone()) {}
6744
6745 BenchmarkFunction& operator=(BenchmarkFunction&& that) {
6746 f = std::move(that.f);
6747 return *this;
6748 }
6749
6750 BenchmarkFunction& operator=(BenchmarkFunction const& that) {
6751 f.reset(that.f->clone());
6752 return *this;
6753 }
6754
6755 void operator()(Chronometer meter) const { f->call(meter); }
6756
6757 private:
6758 std::unique_ptr<callable> f;
6759 };
6760 } // namespace Detail
6761 } // namespace Benchmark
6762 } // namespace Catch
6763
6764 // end catch_benchmark_function.hpp
6765 // start catch_repeat.hpp
6766
6767 // repeat algorithm
6768
6769
6770 #include <type_traits>
6771 #include <utility>
6772
6773 namespace Catch {
6774 namespace Benchmark {
6775 namespace Detail {
6776 template <typename Fun>
6777 struct repeater {
6778 void operator()(int k) const {
6779 for (int i = 0; i < k; ++i) {
6780 fun();
6781 }
6782 }
6783 Fun fun;
6784 };
6785 template <typename Fun>
6786 repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
6787 return { std::forward<Fun>(fun) };
6788 }
6789 } // namespace Detail
6790 } // namespace Benchmark
6791 } // namespace Catch
6792
6793 // end catch_repeat.hpp
6794 // start catch_run_for_at_least.hpp
6795
6796 // Run a function for a minimum amount of time
6797
6798
6799 // start catch_measure.hpp
6800
6801 // Measure
6802
6803
6804 // start catch_timing.hpp
6805
6806 // Timing
6807
6808
6809 #include <tuple>
6810 #include <type_traits>
6811
6812 namespace Catch {
6813 namespace Benchmark {
6814 template <typename Duration, typename Result>
6815 struct Timing {
6816 Duration elapsed;
6817 Result result;
6818 int iterations;
6819 };
6820 template <typename Clock, typename Func, typename... Args>
6821 using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
6822 } // namespace Benchmark
6823 } // namespace Catch
6824
6825 // end catch_timing.hpp
6826 #include <utility>
6827
6828 namespace Catch {
6829 namespace Benchmark {
6830 namespace Detail {
6831 template <typename Clock, typename Fun, typename... Args>
6832 TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
6833 auto start = Clock::now();
6834 auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
6835 auto end = Clock::now();
6836 auto delta = end - start;
6837 return { delta, std::forward<decltype(r)>(r), 1 };
6838 }
6839 } // namespace Detail
6840 } // namespace Benchmark
6841 } // namespace Catch
6842
6843 // end catch_measure.hpp
6844 #include <utility>
6845 #include <type_traits>
6846
6847 namespace Catch {
6848 namespace Benchmark {
6849 namespace Detail {
6850 template <typename Clock, typename Fun>
6851 TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
6852 return Detail::measure<Clock>(fun, iters);
6853 }
6854 template <typename Clock, typename Fun>
6855 TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
6856 Detail::ChronometerModel<Clock> meter;
6857 auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
6858
6859 return { meter.elapsed(), std::move(result), iters };
6860 }
6861
6862 template <typename Clock, typename Fun>
6863 using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
6864
6865 struct optimized_away_error : std::exception {
6866 const char* what() const noexcept override {
6867 return "could not measure benchmark, maybe it was optimized away";
6868 }
6869 };
6870
6871 template <typename Clock, typename Fun>
6872 TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
6873 auto iters = seed;
6874 while (iters < (1 << 30)) {
6875 auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
6876
6877 if (Timing.elapsed >= how_long) {
6878 return { Timing.elapsed, std::move(Timing.result), iters };
6879 }
6880 iters *= 2;
6881 }
6882 throw optimized_away_error{};
6883 }
6884 } // namespace Detail
6885 } // namespace Benchmark
6886 } // namespace Catch
6887
6888 // end catch_run_for_at_least.hpp
6889 #include <algorithm>
6890
6891 namespace Catch {
6892 namespace Benchmark {
6893 template <typename Duration>
6894 struct ExecutionPlan {
6895 int iterations_per_sample;
6896 Duration estimated_duration;
6897 Detail::BenchmarkFunction benchmark;
6898 Duration warmup_time;
6899 int warmup_iterations;
6900
6901 template <typename Duration2>
6902 operator ExecutionPlan<Duration2>() const {
6903 return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
6904 }
6905
6906 template <typename Clock>
6907 std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
6908 // warmup a bit
6909 Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
6910
6911 std::vector<FloatDuration<Clock>> times;
6912 times.reserve(cfg.benchmarkSamples());
6913 std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
6914 Detail::ChronometerModel<Clock> model;
6915 this->benchmark(Chronometer(model, iterations_per_sample));
6916 auto sample_time = model.elapsed() - env.clock_cost.mean;
6917 if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
6918 return sample_time / iterations_per_sample;
6919 });
6920 return times;
6921 }
6922 };
6923 } // namespace Benchmark
6924 } // namespace Catch
6925
6926 // end catch_execution_plan.hpp
6927 // start catch_estimate_clock.hpp
6928
6929 // Environment measurement
6930
6931
6932 // start catch_stats.hpp
6933
6934 // Statistical analysis tools
6935
6936
6937 #include <algorithm>
6938 #include <functional>
6939 #include <vector>
6940 #include <iterator>
6941 #include <numeric>
6942 #include <tuple>
6943 #include <cmath>
6944 #include <utility>
6945 #include <cstddef>
6946 #include <random>
6947
6948 namespace Catch {
6949 namespace Benchmark {
6950 namespace Detail {
6951 using sample = std::vector<double>;
6952
6953 double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
6954
6955 template <typename Iterator>
6956 OutlierClassification classify_outliers(Iterator first, Iterator last) {
6957 std::vector<double> copy(first, last);
6958
6959 auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
6960 auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
6961 auto iqr = q3 - q1;
6962 auto los = q1 - (iqr * 3.);
6963 auto lom = q1 - (iqr * 1.5);
6964 auto him = q3 + (iqr * 1.5);
6965 auto his = q3 + (iqr * 3.);
6966
6967 OutlierClassification o;
6968 for (; first != last; ++first) {
6969 auto&& t = *first;
6970 if (t < los) ++o.low_severe;
6971 else if (t < lom) ++o.low_mild;
6972 else if (t > his) ++o.high_severe;
6973 else if (t > him) ++o.high_mild;
6974 ++o.samples_seen;
6975 }
6976 return o;
6977 }
6978
6979 template <typename Iterator>
6980 double mean(Iterator first, Iterator last) {
6981 auto count = last - first;
6982 double sum = std::accumulate(first, last, 0.);
6983 return sum / count;
6984 }
6985
6986 template <typename URng, typename Iterator, typename Estimator>
6987 sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
6988 auto n = last - first;
6989 std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
6990
6991 sample out;
6992 out.reserve(resamples);
6993 std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
6994 std::vector<double> resampled;
6995 resampled.reserve(n);
6996 std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
6997 return estimator(resampled.begin(), resampled.end());
6998 });
6999 std::sort(out.begin(), out.end());
7000 return out;
7001 }
7002
7003 template <typename Estimator, typename Iterator>
7004 sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
7005 auto n = last - first;
7006 auto second = std::next(first);
7007 sample results;
7008 results.reserve(n);
7009
7010 for (auto it = first; it != last; ++it) {
7011 std::iter_swap(it, first);
7012 results.push_back(estimator(second, last));
7013 }
7014
7015 return results;
7016 }
7017
7018 inline double normal_cdf(double x) {
7019 return std::erfc(-x / std::sqrt(2.0)) / 2.0;
7020 }
7021
7022 double erfc_inv(double x);
7023
7024 double normal_quantile(double p);
7025
7026 template <typename Iterator, typename Estimator>
7027 Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
7028 auto n_samples = last - first;
7029
7030 double point = estimator(first, last);
7031 // Degenerate case with a single sample
7032 if (n_samples == 1) return { point, point, point, confidence_level };
7033
7034 sample jack = jackknife(estimator, first, last);
7035 double jack_mean = mean(jack.begin(), jack.end());
7036 double sum_squares, sum_cubes;
7037 std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
7038 auto d = jack_mean - x;
7039 auto d2 = d * d;
7040 auto d3 = d2 * d;
7041 return { sqcb.first + d2, sqcb.second + d3 };
7042 });
7043
7044 double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
7045 int n = static_cast<int>(resample.size());
7046 double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
7047 // degenerate case with uniform samples
7048 if (prob_n == 0) return { point, point, point, confidence_level };
7049
7050 double bias = normal_quantile(prob_n);
7051 double z1 = normal_quantile((1. - confidence_level) / 2.);
7052
7053 auto cumn = [n](double x) -> int {
7054 return std::lround(normal_cdf(x) * n); };
7055 auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
7056 double b1 = bias + z1;
7057 double b2 = bias - z1;
7058 double a1 = a(b1);
7059 double a2 = a(b2);
7060 auto lo = (std::max)(cumn(a1), 0);
7061 auto hi = (std::min)(cumn(a2), n - 1);
7062
7063 return { point, resample[lo], resample[hi], confidence_level };
7064 }
7065
7066 double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
7067
7068 struct bootstrap_analysis {
7069 Estimate<double> mean;
7070 Estimate<double> standard_deviation;
7071 double outlier_variance;
7072 };
7073
7074 bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
7075 } // namespace Detail
7076 } // namespace Benchmark
7077 } // namespace Catch
7078
7079 // end catch_stats.hpp
7080 #include <algorithm>
7081 #include <iterator>
7082 #include <tuple>
7083 #include <vector>
7084 #include <cmath>
7085
7086 namespace Catch {
7087 namespace Benchmark {
7088 namespace Detail {
7089 template <typename Clock>
7090 std::vector<double> resolution(int k) {
7091 std::vector<TimePoint<Clock>> times;
7092 times.reserve(k + 1);
7093 std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
7094
7095 std::vector<double> deltas;
7096 deltas.reserve(k);
7097 std::transform(std::next(times.begin()), times.end(), times.begin(),
7098 std::back_inserter(deltas),
7099 [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
7100
7101 return deltas;
7102 }
7103
7104 const auto warmup_iterations = 10000;
7105 const auto warmup_time = std::chrono::milliseconds(100);
7106 const auto minimum_ticks = 1000;
7107 const auto warmup_seed = 10000;
7108 const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
7109 const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
7110 const auto clock_cost_estimation_tick_limit = 100000;
7111 const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
7112 const auto clock_cost_estimation_iterations = 10000;
7113
7114 template <typename Clock>
7115 int warmup() {
7116 return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
7117 .iterations;
7118 }
7119 template <typename Clock>
7120 EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
7121 auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
7122 .result;
7123 return {
7124 FloatDuration<Clock>(mean(r.begin(), r.end())),
7125 classify_outliers(r.begin(), r.end()),
7126 };
7127 }
7128 template <typename Clock>
7129 EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
7130 auto time_limit = (std::min)(
7131 resolution * clock_cost_estimation_tick_limit,
7132 FloatDuration<Clock>(clock_cost_estimation_time_limit));
7133 auto time_clock = [](int k) {
7134 return Detail::measure<Clock>([k] {
7135 for (int i = 0; i < k; ++i) {
7136 volatile auto ignored = Clock::now();
7137 (void)ignored;
7138 }
7139 }).elapsed;
7140 };
7141 time_clock(1);
7142 int iters = clock_cost_estimation_iterations;
7143 auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
7144 std::vector<double> times;
7145 int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
7146 times.reserve(nsamples);
7147 std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
7148 return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
7149 });
7150 return {
7151 FloatDuration<Clock>(mean(times.begin(), times.end())),
7152 classify_outliers(times.begin(), times.end()),
7153 };
7154 }
7155
7156 template <typename Clock>
7157 Environment<FloatDuration<Clock>> measure_environment() {
7158 static Environment<FloatDuration<Clock>>* env = nullptr;
7159 if (env) {
7160 return *env;
7161 }
7162
7163 auto iters = Detail::warmup<Clock>();
7164 auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
7165 auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
7166
7167 env = new Environment<FloatDuration<Clock>>{ resolution, cost };
7168 return *env;
7169 }
7170 } // namespace Detail
7171 } // namespace Benchmark
7172 } // namespace Catch
7173
7174 // end catch_estimate_clock.hpp
7175 // start catch_analyse.hpp
7176
7177 // Run and analyse one benchmark
7178
7179
7180 // start catch_sample_analysis.hpp
7181
7182 // Benchmark results
7183
7184
7185 #include <algorithm>
7186 #include <vector>
7187 #include <string>
7188 #include <iterator>
7189
7190 namespace Catch {
7191 namespace Benchmark {
7192 template <typename Duration>
7193 struct SampleAnalysis {
7194 std::vector<Duration> samples;
7195 Estimate<Duration> mean;
7196 Estimate<Duration> standard_deviation;
7197 OutlierClassification outliers;
7198 double outlier_variance;
7199
7200 template <typename Duration2>
7201 operator SampleAnalysis<Duration2>() const {
7202 std::vector<Duration2> samples2;
7203 samples2.reserve(samples.size());
7204 std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
7205 return {
7206 std::move(samples2),
7207 mean,
7208 standard_deviation,
7209 outliers,
7210 outlier_variance,
7211 };
7212 }
7213 };
7214 } // namespace Benchmark
7215 } // namespace Catch
7216
7217 // end catch_sample_analysis.hpp
7218 #include <algorithm>
7219 #include <iterator>
7220 #include <vector>
7221
7222 namespace Catch {
7223 namespace Benchmark {
7224 namespace Detail {
7225 template <typename Duration, typename Iterator>
7226 SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
7227 if (!cfg.benchmarkNoAnalysis()) {
7228 std::vector<double> samples;
7229 samples.reserve(last - first);
7230 std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
7231
7232 auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
7233 auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
7234
7235 auto wrap_estimate = [](Estimate<double> e) {
7236 return Estimate<Duration> {
7237 Duration(e.point),
7238 Duration(e.lower_bound),
7239 Duration(e.upper_bound),
7240 e.confidence_interval,
7241 };
7242 };
7243 std::vector<Duration> samples2;
7244 samples2.reserve(samples.size());
7245 std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
7246 return {
7247 std::move(samples2),
7248 wrap_estimate(analysis.mean),
7249 wrap_estimate(analysis.standard_deviation),
7250 outliers,
7251 analysis.outlier_variance,
7252 };
7253 } else {
7254 std::vector<Duration> samples;
7255 samples.reserve(last - first);
7256
7257 Duration mean = Duration(0);
7258 int i = 0;
7259 for (auto it = first; it < last; ++it, ++i) {
7260 samples.push_back(Duration(*it));
7261 mean += Duration(*it);
7262 }
7263 mean /= i;
7264
7265 return {
7266 std::move(samples),
7267 Estimate<Duration>{mean, mean, mean, 0.0},
7268 Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
7269 OutlierClassification{},
7270 0.0
7271 };
7272 }
7273 }
7274 } // namespace Detail
7275 } // namespace Benchmark
7276 } // namespace Catch
7277
7278 // end catch_analyse.hpp
7279 #include <algorithm>
7280 #include <functional>
7281 #include <string>
7282 #include <vector>
7283 #include <cmath>
7284
7285 namespace Catch {
7286 namespace Benchmark {
7287 struct Benchmark {
7288 Benchmark(std::string &&name)
7289 : name(std::move(name)) {}
7290
7291 template <class FUN>
7292 Benchmark(std::string &&name, FUN &&func)
7293 : fun(std::move(func)), name(std::move(name)) {}
7294
7295 template <typename Clock>
7296 ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
7297 auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
7298 auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
7299 auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
7300 int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
7301 return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
7302 }
7303
7304 template <typename Clock = default_clock>
7305 void run() {
7306 IConfigPtr cfg = getCurrentContext().getConfig();
7307
7308 auto env = Detail::measure_environment<Clock>();
7309
7310 getResultCapture().benchmarkPreparing(name);
7311 CATCH_TRY{
7312 auto plan = user_code([&] {
7313 return prepare<Clock>(*cfg, env);
7314 });
7315
7316 BenchmarkInfo info {
7317 name,
7318 plan.estimated_duration.count(),
7319 plan.iterations_per_sample,
7320 cfg->benchmarkSamples(),
7321 cfg->benchmarkResamples(),
7322 env.clock_resolution.mean.count(),
7323 env.clock_cost.mean.count()
7324 };
7325
7326 getResultCapture().benchmarkStarting(info);
7327
7328 auto samples = user_code([&] {
7329 return plan.template run<Clock>(*cfg, env);
7330 });
7331
7332 auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
7333 BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
7334 getResultCapture().benchmarkEnded(stats);
7335
7336 } CATCH_CATCH_ALL{
7337 if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
7338 std::rethrow_exception(std::current_exception());
7339 }
7340 }
7341
7342 // sets lambda to be used in fun *and* executes benchmark!
7343 template <typename Fun,
7344 typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
7345 Benchmark & operator=(Fun func) {
7346 fun = Detail::BenchmarkFunction(func);
7347 run();
7348 return *this;
7349 }
7350
7351 explicit operator bool() {
7352 return true;
7353 }
7354
7355 private:
7356 Detail::BenchmarkFunction fun;
7357 std::string name;
7358 };
7359 }
7360 } // namespace Catch
7361
7362 #define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
7363 #define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
7364
7365 #define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
7366 if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
7367 BenchmarkName = [&](int benchmarkIndex)
7368
7369 #define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
7370 if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
7371 BenchmarkName = [&]
7372
7373 // end catch_benchmark.hpp
7374 // start catch_constructor.hpp
7375
7376 // Constructor and destructor helpers
7377
7378
7379 #include <type_traits>
7380
7381 namespace Catch {
7382 namespace Benchmark {
7383 namespace Detail {
7384 template <typename T, bool Destruct>
7385 struct ObjectStorage
7386 {
7387 using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
7388
7389 ObjectStorage() : data() {}
7390
7391 ObjectStorage(const ObjectStorage& other)
7392 {
7393 new(&data) T(other.stored_object());
7394 }
7395
7396 ObjectStorage(ObjectStorage&& other)
7397 {
7398 new(&data) T(std::move(other.stored_object()));
7399 }
7400
7401 ~ObjectStorage() { destruct_on_exit<T>(); }
7402
7403 template <typename... Args>
7404 void construct(Args&&... args)
7405 {
7406 new (&data) T(std::forward<Args>(args)...);
7407 }
7408
7409 template <bool AllowManualDestruction = !Destruct>
7410 typename std::enable_if<AllowManualDestruction>::type destruct()
7411 {
7412 stored_object().~T();
7413 }
7414
7415 private:
7416 // If this is a constructor benchmark, destruct the underlying object
7417 template <typename U>
7418 void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
7419 // Otherwise, don't
7420 template <typename U>
7421 void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
7422
7423 T& stored_object() {
7424 return *static_cast<T*>(static_cast<void*>(&data));
7425 }
7426
7427 T const& stored_object() const {
7428 return *static_cast<T*>(static_cast<void*>(&data));
7429 }
7430
7431 TStorage data;
7432 };
7433 }
7434
7435 template <typename T>
7436 using storage_for = Detail::ObjectStorage<T, true>;
7437
7438 template <typename T>
7439 using destructable_object = Detail::ObjectStorage<T, false>;
7440 }
7441 }
7442
7443 // end catch_constructor.hpp
7444 // end catch_benchmarking_all.hpp
7445 #endif
7446
7447 #endif // ! CATCH_CONFIG_IMPL_ONLY
7448
7449 #ifdef CATCH_IMPL
7450 // start catch_impl.hpp
7451
7452 #ifdef __clang__
7453 #pragma clang diagnostic push
7454 #pragma clang diagnostic ignored "-Wweak-vtables"
7455 #endif
7456
7457 // Keep these here for external reporters
7458 // start catch_test_case_tracker.h
7459
7460 #include <string>
7461 #include <vector>
7462 #include <memory>
7463
7464 namespace Catch {
7465 namespace TestCaseTracking {
7466
7467 struct NameAndLocation {
7468 std::string name;
7469 SourceLineInfo location;
7470
7471 NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
7472 friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
7473 return lhs.name == rhs.name
7474 && lhs.location == rhs.location;
7475 }
7476 };
7477
7478 class ITracker;
7479
7480 using ITrackerPtr = std::shared_ptr<ITracker>;
7481
7482 class ITracker {
7483 NameAndLocation m_nameAndLocation;
7484
7485 public:
7486 ITracker(NameAndLocation const& nameAndLoc) :
7487 m_nameAndLocation(nameAndLoc)
7488 {}
7489
7490 // static queries
7491 NameAndLocation const& nameAndLocation() const {
7492 return m_nameAndLocation;
7493 }
7494
7495 virtual ~ITracker();
7496
7497 // dynamic queries
7498 virtual bool isComplete() const = 0; // Successfully completed or failed
7499 virtual bool isSuccessfullyCompleted() const = 0;
7500 virtual bool isOpen() const = 0; // Started but not complete
7501 virtual bool hasChildren() const = 0;
7502 virtual bool hasStarted() const = 0;
7503
7504 virtual ITracker& parent() = 0;
7505
7506 // actions
7507 virtual void close() = 0; // Successfully complete
7508 virtual void fail() = 0;
7509 virtual void markAsNeedingAnotherRun() = 0;
7510
7511 virtual void addChild( ITrackerPtr const& child ) = 0;
7512 virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
7513 virtual void openChild() = 0;
7514
7515 // Debug/ checking
7516 virtual bool isSectionTracker() const = 0;
7517 virtual bool isGeneratorTracker() const = 0;
7518 };
7519
7520 class TrackerContext {
7521
7522 enum RunState {
7523 NotStarted,
7524 Executing,
7525 CompletedCycle
7526 };
7527
7528 ITrackerPtr m_rootTracker;
7529 ITracker* m_currentTracker = nullptr;
7530 RunState m_runState = NotStarted;
7531
7532 public:
7533
7534 ITracker& startRun();
7535 void endRun();
7536
7537 void startCycle();
7538 void completeCycle();
7539
7540 bool completedCycle() const;
7541 ITracker& currentTracker();
7542 void setCurrentTracker( ITracker* tracker );
7543 };
7544
7545 class TrackerBase : public ITracker {
7546 protected:
7547 enum CycleState {
7548 NotStarted,
7549 Executing,
7550 ExecutingChildren,
7551 NeedsAnotherRun,
7552 CompletedSuccessfully,
7553 Failed
7554 };
7555
7556 using Children = std::vector<ITrackerPtr>;
7557 TrackerContext& m_ctx;
7558 ITracker* m_parent;
7559 Children m_children;
7560 CycleState m_runState = NotStarted;
7561
7562 public:
7563 TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
7564
7565 bool isComplete() const override;
7566 bool isSuccessfullyCompleted() const override;
7567 bool isOpen() const override;
7568 bool hasChildren() const override;
7569 bool hasStarted() const override {
7570 return m_runState != NotStarted;
7571 }
7572
7573 void addChild( ITrackerPtr const& child ) override;
7574
7575 ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
7576 ITracker& parent() override;
7577
7578 void openChild() override;
7579
7580 bool isSectionTracker() const override;
7581 bool isGeneratorTracker() const override;
7582
7583 void open();
7584
7585 void close() override;
7586 void fail() override;
7587 void markAsNeedingAnotherRun() override;
7588
7589 private:
7590 void moveToParent();
7591 void moveToThis();
7592 };
7593
7594 class SectionTracker : public TrackerBase {
7595 std::vector<std::string> m_filters;
7596 std::string m_trimmed_name;
7597 public:
7598 SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
7599
7600 bool isSectionTracker() const override;
7601
7602 bool isComplete() const override;
7603
7604 static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
7605
7606 void tryOpen();
7607
7608 void addInitialFilters( std::vector<std::string> const& filters );
7609 void addNextFilters( std::vector<std::string> const& filters );
7610 //! Returns filters active in this tracker
7611 std::vector<std::string> const& getFilters() const;
7612 //! Returns whitespace-trimmed name of the tracked section
7613 std::string const& trimmedName() const;
7614 };
7615
7616 } // namespace TestCaseTracking
7617
7618 using TestCaseTracking::ITracker;
7619 using TestCaseTracking::TrackerContext;
7620 using TestCaseTracking::SectionTracker;
7621
7622 } // namespace Catch
7623
7624 // end catch_test_case_tracker.h
7625
7626 // start catch_leak_detector.h
7627
7628 namespace Catch {
7629
7630 struct LeakDetector {
7631 LeakDetector();
7632 ~LeakDetector();
7633 };
7634
7635 }
7636 // end catch_leak_detector.h
7637 // Cpp files will be included in the single-header file here
7638 // start catch_stats.cpp
7639
7640 // Statistical analysis tools
7641
7642 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
7643
7644 #include <cassert>
7645 #include <random>
7646
7647 #if defined(CATCH_CONFIG_USE_ASYNC)
7648 #include <future>
7649 #endif
7650
7651 namespace {
7652 double erf_inv(double x) {
7653 // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
7654 double w, p;
7655
7656 w = -log((1.0 - x) * (1.0 + x));
7657
7658 if (w < 6.250000) {
7659 w = w - 3.125000;
7660 p = -3.6444120640178196996e-21;
7661 p = -1.685059138182016589e-19 + p * w;
7662 p = 1.2858480715256400167e-18 + p * w;
7663 p = 1.115787767802518096e-17 + p * w;
7664 p = -1.333171662854620906e-16 + p * w;
7665 p = 2.0972767875968561637e-17 + p * w;
7666 p = 6.6376381343583238325e-15 + p * w;
7667 p = -4.0545662729752068639e-14 + p * w;
7668 p = -8.1519341976054721522e-14 + p * w;
7669 p = 2.6335093153082322977e-12 + p * w;
7670 p = -1.2975133253453532498e-11 + p * w;
7671 p = -5.4154120542946279317e-11 + p * w;
7672 p = 1.051212273321532285e-09 + p * w;
7673 p = -4.1126339803469836976e-09 + p * w;
7674 p = -2.9070369957882005086e-08 + p * w;
7675 p = 4.2347877827932403518e-07 + p * w;
7676 p = -1.3654692000834678645e-06 + p * w;
7677 p = -1.3882523362786468719e-05 + p * w;
7678 p = 0.0001867342080340571352 + p * w;
7679 p = -0.00074070253416626697512 + p * w;
7680 p = -0.0060336708714301490533 + p * w;
7681 p = 0.24015818242558961693 + p * w;
7682 p = 1.6536545626831027356 + p * w;
7683 } else if (w < 16.000000) {
7684 w = sqrt(w) - 3.250000;
7685 p = 2.2137376921775787049e-09;
7686 p = 9.0756561938885390979e-08 + p * w;
7687 p = -2.7517406297064545428e-07 + p * w;
7688 p = 1.8239629214389227755e-08 + p * w;
7689 p = 1.5027403968909827627e-06 + p * w;
7690 p = -4.013867526981545969e-06 + p * w;
7691 p = 2.9234449089955446044e-06 + p * w;
7692 p = 1.2475304481671778723e-05 + p * w;
7693 p = -4.7318229009055733981e-05 + p * w;
7694 p = 6.8284851459573175448e-05 + p * w;
7695 p = 2.4031110387097893999e-05 + p * w;
7696 p = -0.0003550375203628474796 + p * w;
7697 p = 0.00095328937973738049703 + p * w;
7698 p = -0.0016882755560235047313 + p * w;
7699 p = 0.0024914420961078508066 + p * w;
7700 p = -0.0037512085075692412107 + p * w;
7701 p = 0.005370914553590063617 + p * w;
7702 p = 1.0052589676941592334 + p * w;
7703 p = 3.0838856104922207635 + p * w;
7704 } else {
7705 w = sqrt(w) - 5.000000;
7706 p = -2.7109920616438573243e-11;
7707 p = -2.5556418169965252055e-10 + p * w;
7708 p = 1.5076572693500548083e-09 + p * w;
7709 p = -3.7894654401267369937e-09 + p * w;
7710 p = 7.6157012080783393804e-09 + p * w;
7711 p = -1.4960026627149240478e-08 + p * w;
7712 p = 2.9147953450901080826e-08 + p * w;
7713 p = -6.7711997758452339498e-08 + p * w;
7714 p = 2.2900482228026654717e-07 + p * w;
7715 p = -9.9298272942317002539e-07 + p * w;
7716 p = 4.5260625972231537039e-06 + p * w;
7717 p = -1.9681778105531670567e-05 + p * w;
7718 p = 7.5995277030017761139e-05 + p * w;
7719 p = -0.00021503011930044477347 + p * w;
7720 p = -0.00013871931833623122026 + p * w;
7721 p = 1.0103004648645343977 + p * w;
7722 p = 4.8499064014085844221 + p * w;
7723 }
7724 return p * x;
7725 }
7726
7727 double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
7728 auto m = Catch::Benchmark::Detail::mean(first, last);
7729 double variance = std::accumulate(first, last, 0., [m](double a, double b) {
7730 double diff = b - m;
7731 return a + diff * diff;
7732 }) / (last - first);
7733 return std::sqrt(variance);
7734 }
7735
7736 }
7737
7738 namespace Catch {
7739 namespace Benchmark {
7740 namespace Detail {
7741
7742 double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
7743 auto count = last - first;
7744 double idx = (count - 1) * k / static_cast<double>(q);
7745 int j = static_cast<int>(idx);
7746 double g = idx - j;
7747 std::nth_element(first, first + j, last);
7748 auto xj = first[j];
7749 if (g == 0) return xj;
7750
7751 auto xj1 = *std::min_element(first + (j + 1), last);
7752 return xj + g * (xj1 - xj);
7753 }
7754
7755 double erfc_inv(double x) {
7756 return erf_inv(1.0 - x);
7757 }
7758
7759 double normal_quantile(double p) {
7760 static const double ROOT_TWO = std::sqrt(2.0);
7761
7762 double result = 0.0;
7763 assert(p >= 0 && p <= 1);
7764 if (p < 0 || p > 1) {
7765 return result;
7766 }
7767
7768 result = -erfc_inv(2.0 * p);
7769 // result *= normal distribution standard deviation (1.0) * sqrt(2)
7770 result *= /*sd * */ ROOT_TWO;
7771 // result += normal disttribution mean (0)
7772 return result;
7773 }
7774
7775 double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
7776 double sb = stddev.point;
7777 double mn = mean.point / n;
7778 double mg_min = mn / 2.;
7779 double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
7780 double sg2 = sg * sg;
7781 double sb2 = sb * sb;
7782
7783 auto c_max = [n, mn, sb2, sg2](double x) -> double {
7784 double k = mn - x;
7785 double d = k * k;
7786 double nd = n * d;
7787 double k0 = -n * nd;
7788 double k1 = sb2 - n * sg2 + nd;
7789 double det = k1 * k1 - 4 * sg2 * k0;
7790 return (int)(-2. * k0 / (k1 + std::sqrt(det)));
7791 };
7792
7793 auto var_out = [n, sb2, sg2](double c) {
7794 double nc = n - c;
7795 return (nc / n) * (sb2 - nc * sg2);
7796 };
7797
7798 return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;
7799 }
7800
7801 bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
7802 CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
7803 CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
7804 static std::random_device entropy;
7805 CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
7806
7807 auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
7808
7809 auto mean = &Detail::mean<std::vector<double>::iterator>;
7810 auto stddev = &standard_deviation;
7811
7812 #if defined(CATCH_CONFIG_USE_ASYNC)
7813 auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
7814 auto seed = entropy();
7815 return std::async(std::launch::async, [=] {
7816 std::mt19937 rng(seed);
7817 auto resampled = resample(rng, n_resamples, first, last, f);
7818 return bootstrap(confidence_level, first, last, resampled, f);
7819 });
7820 };
7821
7822 auto mean_future = Estimate(mean);
7823 auto stddev_future = Estimate(stddev);
7824
7825 auto mean_estimate = mean_future.get();
7826 auto stddev_estimate = stddev_future.get();
7827 #else
7828 auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
7829 auto seed = entropy();
7830 std::mt19937 rng(seed);
7831 auto resampled = resample(rng, n_resamples, first, last, f);
7832 return bootstrap(confidence_level, first, last, resampled, f);
7833 };
7834
7835 auto mean_estimate = Estimate(mean);
7836 auto stddev_estimate = Estimate(stddev);
7837 #endif // CATCH_USE_ASYNC
7838
7839 double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
7840
7841 return { mean_estimate, stddev_estimate, outlier_variance };
7842 }
7843 } // namespace Detail
7844 } // namespace Benchmark
7845 } // namespace Catch
7846
7847 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
7848 // end catch_stats.cpp
7849 // start catch_approx.cpp
7850
7851 #include <cmath>
7852 #include <limits>
7853
7854 namespace {
7855
7856 // Performs equivalent check of std::fabs(lhs - rhs) <= margin
7857 // But without the subtraction to allow for INFINITY in comparison
7858 bool marginComparison(double lhs, double rhs, double margin) {
7859 return (lhs + margin >= rhs) && (rhs + margin >= lhs);
7860 }
7861
7862 }
7863
7864 namespace Catch {
7865 namespace Detail {
7866
7867 Approx::Approx ( double value )
7868 : m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
7869 m_margin( 0.0 ),
7870 m_scale( 0.0 ),
7871 m_value( value )
7872 {}
7873
7874 Approx Approx::custom() {
7875 return Approx( 0 );
7876 }
7877
7878 Approx Approx::operator-() const {
7879 auto temp(*this);
7880 temp.m_value = -temp.m_value;
7881 return temp;
7882 }
7883
7884 std::string Approx::toString() const {
7885 ReusableStringStream rss;
7886 rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
7887 return rss.str();
7888 }
7889
7890 bool Approx::equalityComparisonImpl(const double other) const {
7891 // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
7892 // Thanks to Richard Harris for his help refining the scaled margin value
7893 return marginComparison(m_value, other, m_margin)
7894 || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
7895 }
7896
7897 void Approx::setMargin(double newMargin) {
7898 CATCH_ENFORCE(newMargin >= 0,
7899 "Invalid Approx::margin: " << newMargin << '.'
7900 << " Approx::Margin has to be non-negative.");
7901 m_margin = newMargin;
7902 }
7903
7904 void Approx::setEpsilon(double newEpsilon) {
7905 CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
7906 "Invalid Approx::epsilon: " << newEpsilon << '.'
7907 << " Approx::epsilon has to be in [0, 1]");
7908 m_epsilon = newEpsilon;
7909 }
7910
7911 } // end namespace Detail
7912
7913 namespace literals {
7914 Detail::Approx operator "" _a(long double val) {
7915 return Detail::Approx(val);
7916 }
7917 Detail::Approx operator "" _a(unsigned long long val) {
7918 return Detail::Approx(val);
7919 }
7920 } // end namespace literals
7921
7922 std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
7923 return value.toString();
7924 }
7925
7926 } // end namespace Catch
7927 // end catch_approx.cpp
7928 // start catch_assertionhandler.cpp
7929
7930 // start catch_debugger.h
7931
7932 namespace Catch {
7933 bool isDebuggerActive();
7934 }
7935
7936 #ifdef CATCH_PLATFORM_MAC
7937
7938 #if defined(__i386__) || defined(__x86_64__)
7939 #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
7940 #elif defined(__aarch64__)
7941 #define CATCH_TRAP() __asm__(".inst 0xd4200000")
7942 #endif
7943
7944 #elif defined(CATCH_PLATFORM_IPHONE)
7945
7946 // use inline assembler
7947 #if defined(__i386__) || defined(__x86_64__)
7948 #define CATCH_TRAP() __asm__("int $3")
7949 #elif defined(__aarch64__)
7950 #define CATCH_TRAP() __asm__(".inst 0xd4200000")
7951 #elif defined(__arm__) && !defined(__thumb__)
7952 #define CATCH_TRAP() __asm__(".inst 0xe7f001f0")
7953 #elif defined(__arm__) && defined(__thumb__)
7954 #define CATCH_TRAP() __asm__(".inst 0xde01")
7955 #endif
7956
7957 #elif defined(CATCH_PLATFORM_LINUX)
7958 // If we can use inline assembler, do it because this allows us to break
7959 // directly at the location of the failing check instead of breaking inside
7960 // raise() called from it, i.e. one stack frame below.
7961 #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
7962 #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
7963 #else // Fall back to the generic way.
7964 #include <signal.h>
7965
7966 #define CATCH_TRAP() raise(SIGTRAP)
7967 #endif
7968 #elif defined(_MSC_VER)
7969 #define CATCH_TRAP() __debugbreak()
7970 #elif defined(__MINGW32__)
7971 extern "C" __declspec(dllimport) void __stdcall DebugBreak();
7972 #define CATCH_TRAP() DebugBreak()
7973 #endif
7974
7975 #ifndef CATCH_BREAK_INTO_DEBUGGER
7976 #ifdef CATCH_TRAP
7977 #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
7978 #else
7979 #define CATCH_BREAK_INTO_DEBUGGER() []{}()
7980 #endif
7981 #endif
7982
7983 // end catch_debugger.h
7984 // start catch_run_context.h
7985
7986 // start catch_fatal_condition.h
7987
7988 #include <cassert>
7989
7990 namespace Catch {
7991
7992 // Wrapper for platform-specific fatal error (signals/SEH) handlers
7993 //
7994 // Tries to be cooperative with other handlers, and not step over
7995 // other handlers. This means that unknown structured exceptions
7996 // are passed on, previous signal handlers are called, and so on.
7997 //
7998 // Can only be instantiated once, and assumes that once a signal
7999 // is caught, the binary will end up terminating. Thus, there
8000 class FatalConditionHandler {
8001 bool m_started = false;
8002
8003 // Install/disengage implementation for specific platform.
8004 // Should be if-defed to work on current platform, can assume
8005 // engage-disengage 1:1 pairing.
8006 void engage_platform();
8007 void disengage_platform();
8008 public:
8009 // Should also have platform-specific implementations as needed
8010 FatalConditionHandler();
8011 ~FatalConditionHandler();
8012
8013 void engage() {
8014 assert(!m_started && "Handler cannot be installed twice.");
8015 m_started = true;
8016 engage_platform();
8017 }
8018
8019 void disengage() {
8020 assert(m_started && "Handler cannot be uninstalled without being installed first");
8021 m_started = false;
8022 disengage_platform();
8023 }
8024 };
8025
8026 //! Simple RAII guard for (dis)engaging the FatalConditionHandler
8027 class FatalConditionHandlerGuard {
8028 FatalConditionHandler* m_handler;
8029 public:
8030 FatalConditionHandlerGuard(FatalConditionHandler* handler):
8031 m_handler(handler) {
8032 m_handler->engage();
8033 }
8034 ~FatalConditionHandlerGuard() {
8035 m_handler->disengage();
8036 }
8037 };
8038
8039 } // end namespace Catch
8040
8041 // end catch_fatal_condition.h
8042 #include <string>
8043
8044 namespace Catch {
8045
8046 struct IMutableContext;
8047
8048 ///////////////////////////////////////////////////////////////////////////
8049
8050 class RunContext : public IResultCapture, public IRunner {
8051
8052 public:
8053 RunContext( RunContext const& ) = delete;
8054 RunContext& operator =( RunContext const& ) = delete;
8055
8056 explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
8057
8058 ~RunContext() override;
8059
8060 void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
8061 void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
8062
8063 Totals runTest(TestCase const& testCase);
8064
8065 IConfigPtr config() const;
8066 IStreamingReporter& reporter() const;
8067
8068 public: // IResultCapture
8069
8070 // Assertion handlers
8071 void handleExpr
8072 ( AssertionInfo const& info,
8073 ITransientExpression const& expr,
8074 AssertionReaction& reaction ) override;
8075 void handleMessage
8076 ( AssertionInfo const& info,
8077 ResultWas::OfType resultType,
8078 StringRef const& message,
8079 AssertionReaction& reaction ) override;
8080 void handleUnexpectedExceptionNotThrown
8081 ( AssertionInfo const& info,
8082 AssertionReaction& reaction ) override;
8083 void handleUnexpectedInflightException
8084 ( AssertionInfo const& info,
8085 std::string const& message,
8086 AssertionReaction& reaction ) override;
8087 void handleIncomplete
8088 ( AssertionInfo const& info ) override;
8089 void handleNonExpr
8090 ( AssertionInfo const &info,
8091 ResultWas::OfType resultType,
8092 AssertionReaction &reaction ) override;
8093
8094 bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
8095
8096 void sectionEnded( SectionEndInfo const& endInfo ) override;
8097 void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
8098
8099 auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
8100
8101 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
8102 void benchmarkPreparing( std::string const& name ) override;
8103 void benchmarkStarting( BenchmarkInfo const& info ) override;
8104 void benchmarkEnded( BenchmarkStats<> const& stats ) override;
8105 void benchmarkFailed( std::string const& error ) override;
8106 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
8107
8108 void pushScopedMessage( MessageInfo const& message ) override;
8109 void popScopedMessage( MessageInfo const& message ) override;
8110
8111 void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
8112
8113 std::string getCurrentTestName() const override;
8114
8115 const AssertionResult* getLastResult() const override;
8116
8117 void exceptionEarlyReported() override;
8118
8119 void handleFatalErrorCondition( StringRef message ) override;
8120
8121 bool lastAssertionPassed() override;
8122
8123 void assertionPassed() override;
8124
8125 public:
8126 // !TBD We need to do this another way!
8127 bool aborting() const final;
8128
8129 private:
8130
8131 void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
8132 void invokeActiveTestCase();
8133
8134 void resetAssertionInfo();
8135 bool testForMissingAssertions( Counts& assertions );
8136
8137 void assertionEnded( AssertionResult const& result );
8138 void reportExpr
8139 ( AssertionInfo const &info,
8140 ResultWas::OfType resultType,
8141 ITransientExpression const *expr,
8142 bool negated );
8143
8144 void populateReaction( AssertionReaction& reaction );
8145
8146 private:
8147
8148 void handleUnfinishedSections();
8149
8150 TestRunInfo m_runInfo;
8151 IMutableContext& m_context;
8152 TestCase const* m_activeTestCase = nullptr;
8153 ITracker* m_testCaseTracker = nullptr;
8154 Option<AssertionResult> m_lastResult;
8155
8156 IConfigPtr m_config;
8157 Totals m_totals;
8158 IStreamingReporterPtr m_reporter;
8159 std::vector<MessageInfo> m_messages;
8160 std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
8161 AssertionInfo m_lastAssertionInfo;
8162 std::vector<SectionEndInfo> m_unfinishedSections;
8163 std::vector<ITracker*> m_activeSections;
8164 TrackerContext m_trackerContext;
8165 FatalConditionHandler m_fatalConditionhandler;
8166 bool m_lastAssertionPassed = false;
8167 bool m_shouldReportUnexpected = true;
8168 bool m_includeSuccessfulResults;
8169 };
8170
8171 void seedRng(IConfig const& config);
8172 unsigned int rngSeed();
8173 } // end namespace Catch
8174
8175 // end catch_run_context.h
8176 namespace Catch {
8177
8178 namespace {
8179 auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
8180 expr.streamReconstructedExpression( os );
8181 return os;
8182 }
8183 }
8184
8185 LazyExpression::LazyExpression( bool isNegated )
8186 : m_isNegated( isNegated )
8187 {}
8188
8189 LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
8190
8191 LazyExpression::operator bool() const {
8192 return m_transientExpression != nullptr;
8193 }
8194
8195 auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
8196 if( lazyExpr.m_isNegated )
8197 os << "!";
8198
8199 if( lazyExpr ) {
8200 if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
8201 os << "(" << *lazyExpr.m_transientExpression << ")";
8202 else
8203 os << *lazyExpr.m_transientExpression;
8204 }
8205 else {
8206 os << "{** error - unchecked empty expression requested **}";
8207 }
8208 return os;
8209 }
8210
8211 AssertionHandler::AssertionHandler
8212 ( StringRef const& macroName,
8213 SourceLineInfo const& lineInfo,
8214 StringRef capturedExpression,
8215 ResultDisposition::Flags resultDisposition )
8216 : m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
8217 m_resultCapture( getResultCapture() )
8218 {}
8219
8220 void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
8221 m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
8222 }
8223 void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
8224 m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
8225 }
8226
8227 auto AssertionHandler::allowThrows() const -> bool {
8228 return getCurrentContext().getConfig()->allowThrows();
8229 }
8230
8231 void AssertionHandler::complete() {
8232 setCompleted();
8233 if( m_reaction.shouldDebugBreak ) {
8234
8235 // If you find your debugger stopping you here then go one level up on the
8236 // call-stack for the code that caused it (typically a failed assertion)
8237
8238 // (To go back to the test and change execution, jump over the throw, next)
8239 CATCH_BREAK_INTO_DEBUGGER();
8240 }
8241 if (m_reaction.shouldThrow) {
8242 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
8243 throw Catch::TestFailureException();
8244 #else
8245 CATCH_ERROR( "Test failure requires aborting test!" );
8246 #endif
8247 }
8248 }
8249 void AssertionHandler::setCompleted() {
8250 m_completed = true;
8251 }
8252
8253 void AssertionHandler::handleUnexpectedInflightException() {
8254 m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
8255 }
8256
8257 void AssertionHandler::handleExceptionThrownAsExpected() {
8258 m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
8259 }
8260 void AssertionHandler::handleExceptionNotThrownAsExpected() {
8261 m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
8262 }
8263
8264 void AssertionHandler::handleUnexpectedExceptionNotThrown() {
8265 m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
8266 }
8267
8268 void AssertionHandler::handleThrowingCallSkipped() {
8269 m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
8270 }
8271
8272 // This is the overload that takes a string and infers the Equals matcher from it
8273 // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
8274 void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString ) {
8275 handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
8276 }
8277
8278 } // namespace Catch
8279 // end catch_assertionhandler.cpp
8280 // start catch_assertionresult.cpp
8281
8282 namespace Catch {
8283 AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
8284 lazyExpression(_lazyExpression),
8285 resultType(_resultType) {}
8286
8287 std::string AssertionResultData::reconstructExpression() const {
8288
8289 if( reconstructedExpression.empty() ) {
8290 if( lazyExpression ) {
8291 ReusableStringStream rss;
8292 rss << lazyExpression;
8293 reconstructedExpression = rss.str();
8294 }
8295 }
8296 return reconstructedExpression;
8297 }
8298
8299 AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
8300 : m_info( info ),
8301 m_resultData( data )
8302 {}
8303
8304 // Result was a success
8305 bool AssertionResult::succeeded() const {
8306 return Catch::isOk( m_resultData.resultType );
8307 }
8308
8309 // Result was a success, or failure is suppressed
8310 bool AssertionResult::isOk() const {
8311 return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
8312 }
8313
8314 ResultWas::OfType AssertionResult::getResultType() const {
8315 return m_resultData.resultType;
8316 }
8317
8318 bool AssertionResult::hasExpression() const {
8319 return !m_info.capturedExpression.empty();
8320 }
8321
8322 bool AssertionResult::hasMessage() const {
8323 return !m_resultData.message.empty();
8324 }
8325
8326 std::string AssertionResult::getExpression() const {
8327 // Possibly overallocating by 3 characters should be basically free
8328 std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
8329 if (isFalseTest(m_info.resultDisposition)) {
8330 expr += "!(";
8331 }
8332 expr += m_info.capturedExpression;
8333 if (isFalseTest(m_info.resultDisposition)) {
8334 expr += ')';
8335 }
8336 return expr;
8337 }
8338
8339 std::string AssertionResult::getExpressionInMacro() const {
8340 std::string expr;
8341 if( m_info.macroName.empty() )
8342 expr = static_cast<std::string>(m_info.capturedExpression);
8343 else {
8344 expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
8345 expr += m_info.macroName;
8346 expr += "( ";
8347 expr += m_info.capturedExpression;
8348 expr += " )";
8349 }
8350 return expr;
8351 }
8352
8353 bool AssertionResult::hasExpandedExpression() const {
8354 return hasExpression() && getExpandedExpression() != getExpression();
8355 }
8356
8357 std::string AssertionResult::getExpandedExpression() const {
8358 std::string expr = m_resultData.reconstructExpression();
8359 return expr.empty()
8360 ? getExpression()
8361 : expr;
8362 }
8363
8364 std::string AssertionResult::getMessage() const {
8365 return m_resultData.message;
8366 }
8367 SourceLineInfo AssertionResult::getSourceInfo() const {
8368 return m_info.lineInfo;
8369 }
8370
8371 StringRef AssertionResult::getTestMacroName() const {
8372 return m_info.macroName;
8373 }
8374
8375 } // end namespace Catch
8376 // end catch_assertionresult.cpp
8377 // start catch_capture_matchers.cpp
8378
8379 namespace Catch {
8380
8381 using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
8382
8383 // This is the general overload that takes a any string matcher
8384 // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
8385 // the Equals matcher (so the header does not mention matchers)
8386 void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString ) {
8387 std::string exceptionMessage = Catch::translateActiveException();
8388 MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
8389 handler.handleExpr( expr );
8390 }
8391
8392 } // namespace Catch
8393 // end catch_capture_matchers.cpp
8394 // start catch_commandline.cpp
8395
8396 // start catch_commandline.h
8397
8398 // start catch_clara.h
8399
8400 // Use Catch's value for console width (store Clara's off to the side, if present)
8401 #ifdef CLARA_CONFIG_CONSOLE_WIDTH
8402 #define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
8403 #undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
8404 #endif
8405 #define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
8406
8407 #ifdef __clang__
8408 #pragma clang diagnostic push
8409 #pragma clang diagnostic ignored "-Wweak-vtables"
8410 #pragma clang diagnostic ignored "-Wexit-time-destructors"
8411 #pragma clang diagnostic ignored "-Wshadow"
8412 #endif
8413
8414 // start clara.hpp
8415 // Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
8416 //
8417 // Distributed under the Boost Software License, Version 1.0. (See accompanying
8418 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8419 //
8420 // See https://github.com/philsquared/Clara for more details
8421
8422 // Clara v1.1.5
8423
8424
8425 #ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
8426 #define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
8427 #endif
8428
8429 #ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
8430 #define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
8431 #endif
8432
8433 #ifndef CLARA_CONFIG_OPTIONAL_TYPE
8434 #ifdef __has_include
8435 #if __has_include(<optional>) && __cplusplus >= 201703L
8436 #include <optional>
8437 #define CLARA_CONFIG_OPTIONAL_TYPE std::optional
8438 #endif
8439 #endif
8440 #endif
8441
8442 // ----------- #included from clara_textflow.hpp -----------
8443
8444 // TextFlowCpp
8445 //
8446 // A single-header library for wrapping and laying out basic text, by Phil Nash
8447 //
8448 // Distributed under the Boost Software License, Version 1.0. (See accompanying
8449 // file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8450 //
8451 // This project is hosted at https://github.com/philsquared/textflowcpp
8452
8453
8454 #include <cassert>
8455 #include <ostream>
8456 #include <sstream>
8457 #include <vector>
8458
8459 #ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
8460 #define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
8461 #endif
8462
8463 namespace Catch {
8464 namespace clara {
8465 namespace TextFlow {
8466
8467 inline auto isWhitespace(char c) -> bool {
8468 static std::string chars = " \t\n\r";
8469 return chars.find(c) != std::string::npos;
8470 }
8471 inline auto isBreakableBefore(char c) -> bool {
8472 static std::string chars = "[({<|";
8473 return chars.find(c) != std::string::npos;
8474 }
8475 inline auto isBreakableAfter(char c) -> bool {
8476 static std::string chars = "])}>.,:;*+-=&/\\";
8477 return chars.find(c) != std::string::npos;
8478 }
8479
8480 class Columns;
8481
8482 class Column {
8483 std::vector<std::string> m_strings;
8484 size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
8485 size_t m_indent = 0;
8486 size_t m_initialIndent = std::string::npos;
8487
8488 public:
8489 class iterator {
8490 friend Column;
8491
8492 Column const& m_column;
8493 size_t m_stringIndex = 0;
8494 size_t m_pos = 0;
8495
8496 size_t m_len = 0;
8497 size_t m_end = 0;
8498 bool m_suffix = false;
8499
8500 iterator(Column const& column, size_t stringIndex)
8501 : m_column(column),
8502 m_stringIndex(stringIndex) {}
8503
8504 auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
8505
8506 auto isBoundary(size_t at) const -> bool {
8507 assert(at > 0);
8508 assert(at <= line().size());
8509
8510 return at == line().size() ||
8511 (isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
8512 isBreakableBefore(line()[at]) ||
8513 isBreakableAfter(line()[at - 1]);
8514 }
8515
8516 void calcLength() {
8517 assert(m_stringIndex < m_column.m_strings.size());
8518
8519 m_suffix = false;
8520 auto width = m_column.m_width - indent();
8521 m_end = m_pos;
8522 if (line()[m_pos] == '\n') {
8523 ++m_end;
8524 }
8525 while (m_end < line().size() && line()[m_end] != '\n')
8526 ++m_end;
8527
8528 if (m_end < m_pos + width) {
8529 m_len = m_end - m_pos;
8530 } else {
8531 size_t len = width;
8532 while (len > 0 && !isBoundary(m_pos + len))
8533 --len;
8534 while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
8535 --len;
8536
8537 if (len > 0) {
8538 m_len = len;
8539 } else {
8540 m_suffix = true;
8541 m_len = width - 1;
8542 }
8543 }
8544 }
8545
8546 auto indent() const -> size_t {
8547 auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
8548 return initial == std::string::npos ? m_column.m_indent : initial;
8549 }
8550
8551 auto addIndentAndSuffix(std::string const &plain) const -> std::string {
8552 return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
8553 }
8554
8555 public:
8556 using difference_type = std::ptrdiff_t;
8557 using value_type = std::string;
8558 using pointer = value_type * ;
8559 using reference = value_type & ;
8560 using iterator_category = std::forward_iterator_tag;
8561
8562 explicit iterator(Column const& column) : m_column(column) {
8563 assert(m_column.m_width > m_column.m_indent);
8564 assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
8565 calcLength();
8566 if (m_len == 0)
8567 m_stringIndex++; // Empty string
8568 }
8569
8570 auto operator *() const -> std::string {
8571 assert(m_stringIndex < m_column.m_strings.size());
8572 assert(m_pos <= m_end);
8573 return addIndentAndSuffix(line().substr(m_pos, m_len));
8574 }
8575
8576 auto operator ++() -> iterator& {
8577 m_pos += m_len;
8578 if (m_pos < line().size() && line()[m_pos] == '\n')
8579 m_pos += 1;
8580 else
8581 while (m_pos < line().size() && isWhitespace(line()[m_pos]))
8582 ++m_pos;
8583
8584 if (m_pos == line().size()) {
8585 m_pos = 0;
8586 ++m_stringIndex;
8587 }
8588 if (m_stringIndex < m_column.m_strings.size())
8589 calcLength();
8590 return *this;
8591 }
8592 auto operator ++(int) -> iterator {
8593 iterator prev(*this);
8594 operator++();
8595 return prev;
8596 }
8597
8598 auto operator ==(iterator const& other) const -> bool {
8599 return
8600 m_pos == other.m_pos &&
8601 m_stringIndex == other.m_stringIndex &&
8602 &m_column == &other.m_column;
8603 }
8604 auto operator !=(iterator const& other) const -> bool {
8605 return !operator==(other);
8606 }
8607 };
8608 using const_iterator = iterator;
8609
8610 explicit Column(std::string const& text) { m_strings.push_back(text); }
8611
8612 auto width(size_t newWidth) -> Column& {
8613 assert(newWidth > 0);
8614 m_width = newWidth;
8615 return *this;
8616 }
8617 auto indent(size_t newIndent) -> Column& {
8618 m_indent = newIndent;
8619 return *this;
8620 }
8621 auto initialIndent(size_t newIndent) -> Column& {
8622 m_initialIndent = newIndent;
8623 return *this;
8624 }
8625
8626 auto width() const -> size_t { return m_width; }
8627 auto begin() const -> iterator { return iterator(*this); }
8628 auto end() const -> iterator { return { *this, m_strings.size() }; }
8629
8630 inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
8631 bool first = true;
8632 for (auto line : col) {
8633 if (first)
8634 first = false;
8635 else
8636 os << "\n";
8637 os << line;
8638 }
8639 return os;
8640 }
8641
8642 auto operator + (Column const& other)->Columns;
8643
8644 auto toString() const -> std::string {
8645 std::ostringstream oss;
8646 oss << *this;
8647 return oss.str();
8648 }
8649 };
8650
8651 class Spacer : public Column {
8652
8653 public:
8654 explicit Spacer(size_t spaceWidth) : Column("") {
8655 width(spaceWidth);
8656 }
8657 };
8658
8659 class Columns {
8660 std::vector<Column> m_columns;
8661
8662 public:
8663
8664 class iterator {
8665 friend Columns;
8666 struct EndTag {};
8667
8668 std::vector<Column> const& m_columns;
8669 std::vector<Column::iterator> m_iterators;
8670 size_t m_activeIterators;
8671
8672 iterator(Columns const& columns, EndTag)
8673 : m_columns(columns.m_columns),
8674 m_activeIterators(0) {
8675 m_iterators.reserve(m_columns.size());
8676
8677 for (auto const& col : m_columns)
8678 m_iterators.push_back(col.end());
8679 }
8680
8681 public:
8682 using difference_type = std::ptrdiff_t;
8683 using value_type = std::string;
8684 using pointer = value_type * ;
8685 using reference = value_type & ;
8686 using iterator_category = std::forward_iterator_tag;
8687
8688 explicit iterator(Columns const& columns)
8689 : m_columns(columns.m_columns),
8690 m_activeIterators(m_columns.size()) {
8691 m_iterators.reserve(m_columns.size());
8692
8693 for (auto const& col : m_columns)
8694 m_iterators.push_back(col.begin());
8695 }
8696
8697 auto operator ==(iterator const& other) const -> bool {
8698 return m_iterators == other.m_iterators;
8699 }
8700 auto operator !=(iterator const& other) const -> bool {
8701 return m_iterators != other.m_iterators;
8702 }
8703 auto operator *() const -> std::string {
8704 std::string row, padding;
8705
8706 for (size_t i = 0; i < m_columns.size(); ++i) {
8707 auto width = m_columns[i].width();
8708 if (m_iterators[i] != m_columns[i].end()) {
8709 std::string col = *m_iterators[i];
8710 row += padding + col;
8711 if (col.size() < width)
8712 padding = std::string(width - col.size(), ' ');
8713 else
8714 padding = "";
8715 } else {
8716 padding += std::string(width, ' ');
8717 }
8718 }
8719 return row;
8720 }
8721 auto operator ++() -> iterator& {
8722 for (size_t i = 0; i < m_columns.size(); ++i) {
8723 if (m_iterators[i] != m_columns[i].end())
8724 ++m_iterators[i];
8725 }
8726 return *this;
8727 }
8728 auto operator ++(int) -> iterator {
8729 iterator prev(*this);
8730 operator++();
8731 return prev;
8732 }
8733 };
8734 using const_iterator = iterator;
8735
8736 auto begin() const -> iterator { return iterator(*this); }
8737 auto end() const -> iterator { return { *this, iterator::EndTag() }; }
8738
8739 auto operator += (Column const& col) -> Columns& {
8740 m_columns.push_back(col);
8741 return *this;
8742 }
8743 auto operator + (Column const& col) -> Columns {
8744 Columns combined = *this;
8745 combined += col;
8746 return combined;
8747 }
8748
8749 inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
8750
8751 bool first = true;
8752 for (auto line : cols) {
8753 if (first)
8754 first = false;
8755 else
8756 os << "\n";
8757 os << line;
8758 }
8759 return os;
8760 }
8761
8762 auto toString() const -> std::string {
8763 std::ostringstream oss;
8764 oss << *this;
8765 return oss.str();
8766 }
8767 };
8768
8769 inline auto Column::operator + (Column const& other) -> Columns {
8770 Columns cols;
8771 cols += *this;
8772 cols += other;
8773 return cols;
8774 }
8775 }
8776
8777 }
8778 }
8779
8780 // ----------- end of #include from clara_textflow.hpp -----------
8781 // ........... back in clara.hpp
8782
8783 #include <cctype>
8784 #include <string>
8785 #include <memory>
8786 #include <set>
8787 #include <algorithm>
8788
8789 #if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
8790 #define CATCH_PLATFORM_WINDOWS
8791 #endif
8792
8793 namespace Catch { namespace clara {
8794 namespace detail {
8795
8796 // Traits for extracting arg and return type of lambdas (for single argument lambdas)
8797 template<typename L>
8798 struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
8799
8800 template<typename ClassT, typename ReturnT, typename... Args>
8801 struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
8802 static const bool isValid = false;
8803 };
8804
8805 template<typename ClassT, typename ReturnT, typename ArgT>
8806 struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
8807 static const bool isValid = true;
8808 using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
8809 using ReturnType = ReturnT;
8810 };
8811
8812 class TokenStream;
8813
8814 // Transport for raw args (copied from main args, or supplied via init list for testing)
8815 class Args {
8816 friend TokenStream;
8817 std::string m_exeName;
8818 std::vector<std::string> m_args;
8819
8820 public:
8821 Args( int argc, char const* const* argv )
8822 : m_exeName(argv[0]),
8823 m_args(argv + 1, argv + argc) {}
8824
8825 Args( std::initializer_list<std::string> args )
8826 : m_exeName( *args.begin() ),
8827 m_args( args.begin()+1, args.end() )
8828 {}
8829
8830 auto exeName() const -> std::string {
8831 return m_exeName;
8832 }
8833 };
8834
8835 // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
8836 // may encode an option + its argument if the : or = form is used
8837 enum class TokenType {
8838 Option, Argument
8839 };
8840 struct Token {
8841 TokenType type;
8842 std::string token;
8843 };
8844
8845 inline auto isOptPrefix( char c ) -> bool {
8846 return c == '-'
8847 #ifdef CATCH_PLATFORM_WINDOWS
8848 || c == '/'
8849 #endif
8850 ;
8851 }
8852
8853 // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
8854 class TokenStream {
8855 using Iterator = std::vector<std::string>::const_iterator;
8856 Iterator it;
8857 Iterator itEnd;
8858 std::vector<Token> m_tokenBuffer;
8859
8860 void loadBuffer() {
8861 m_tokenBuffer.resize( 0 );
8862
8863 // Skip any empty strings
8864 while( it != itEnd && it->empty() )
8865 ++it;
8866
8867 if( it != itEnd ) {
8868 auto const &next = *it;
8869 if( isOptPrefix( next[0] ) ) {
8870 auto delimiterPos = next.find_first_of( " :=" );
8871 if( delimiterPos != std::string::npos ) {
8872 m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
8873 m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
8874 } else {
8875 if( next[1] != '-' && next.size() > 2 ) {
8876 std::string opt = "- ";
8877 for( size_t i = 1; i < next.size(); ++i ) {
8878 opt[1] = next[i];
8879 m_tokenBuffer.push_back( { TokenType::Option, opt } );
8880 }
8881 } else {
8882 m_tokenBuffer.push_back( { TokenType::Option, next } );
8883 }
8884 }
8885 } else {
8886 m_tokenBuffer.push_back( { TokenType::Argument, next } );
8887 }
8888 }
8889 }
8890
8891 public:
8892 explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
8893
8894 TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
8895 loadBuffer();
8896 }
8897
8898 explicit operator bool() const {
8899 return !m_tokenBuffer.empty() || it != itEnd;
8900 }
8901
8902 auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
8903
8904 auto operator*() const -> Token {
8905 assert( !m_tokenBuffer.empty() );
8906 return m_tokenBuffer.front();
8907 }
8908
8909 auto operator->() const -> Token const * {
8910 assert( !m_tokenBuffer.empty() );
8911 return &m_tokenBuffer.front();
8912 }
8913
8914 auto operator++() -> TokenStream & {
8915 if( m_tokenBuffer.size() >= 2 ) {
8916 m_tokenBuffer.erase( m_tokenBuffer.begin() );
8917 } else {
8918 if( it != itEnd )
8919 ++it;
8920 loadBuffer();
8921 }
8922 return *this;
8923 }
8924 };
8925
8926 class ResultBase {
8927 public:
8928 enum Type {
8929 Ok, LogicError, RuntimeError
8930 };
8931
8932 protected:
8933 ResultBase( Type type ) : m_type( type ) {}
8934 virtual ~ResultBase() = default;
8935
8936 virtual void enforceOk() const = 0;
8937
8938 Type m_type;
8939 };
8940
8941 template<typename T>
8942 class ResultValueBase : public ResultBase {
8943 public:
8944 auto value() const -> T const & {
8945 enforceOk();
8946 return m_value;
8947 }
8948
8949 protected:
8950 ResultValueBase( Type type ) : ResultBase( type ) {}
8951
8952 ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
8953 if( m_type == ResultBase::Ok )
8954 new( &m_value ) T( other.m_value );
8955 }
8956
8957 ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
8958 new( &m_value ) T( value );
8959 }
8960
8961 auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
8962 if( m_type == ResultBase::Ok )
8963 m_value.~T();
8964 ResultBase::operator=(other);
8965 if( m_type == ResultBase::Ok )
8966 new( &m_value ) T( other.m_value );
8967 return *this;
8968 }
8969
8970 ~ResultValueBase() override {
8971 if( m_type == Ok )
8972 m_value.~T();
8973 }
8974
8975 union {
8976 T m_value;
8977 };
8978 };
8979
8980 template<>
8981 class ResultValueBase<void> : public ResultBase {
8982 protected:
8983 using ResultBase::ResultBase;
8984 };
8985
8986 template<typename T = void>
8987 class BasicResult : public ResultValueBase<T> {
8988 public:
8989 template<typename U>
8990 explicit BasicResult( BasicResult<U> const &other )
8991 : ResultValueBase<T>( other.type() ),
8992 m_errorMessage( other.errorMessage() )
8993 {
8994 assert( type() != ResultBase::Ok );
8995 }
8996
8997 template<typename U>
8998 static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
8999 static auto ok() -> BasicResult { return { ResultBase::Ok }; }
9000 static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
9001 static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
9002
9003 explicit operator bool() const { return m_type == ResultBase::Ok; }
9004 auto type() const -> ResultBase::Type { return m_type; }
9005 auto errorMessage() const -> std::string { return m_errorMessage; }
9006
9007 protected:
9008 void enforceOk() const override {
9009
9010 // Errors shouldn't reach this point, but if they do
9011 // the actual error message will be in m_errorMessage
9012 assert( m_type != ResultBase::LogicError );
9013 assert( m_type != ResultBase::RuntimeError );
9014 if( m_type != ResultBase::Ok )
9015 std::abort();
9016 }
9017
9018 std::string m_errorMessage; // Only populated if resultType is an error
9019
9020 BasicResult( ResultBase::Type type, std::string const &message )
9021 : ResultValueBase<T>(type),
9022 m_errorMessage(message)
9023 {
9024 assert( m_type != ResultBase::Ok );
9025 }
9026
9027 using ResultValueBase<T>::ResultValueBase;
9028 using ResultBase::m_type;
9029 };
9030
9031 enum class ParseResultType {
9032 Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
9033 };
9034
9035 class ParseState {
9036 public:
9037
9038 ParseState( ParseResultType type, TokenStream const &remainingTokens )
9039 : m_type(type),
9040 m_remainingTokens( remainingTokens )
9041 {}
9042
9043 auto type() const -> ParseResultType { return m_type; }
9044 auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
9045
9046 private:
9047 ParseResultType m_type;
9048 TokenStream m_remainingTokens;
9049 };
9050
9051 using Result = BasicResult<void>;
9052 using ParserResult = BasicResult<ParseResultType>;
9053 using InternalParseResult = BasicResult<ParseState>;
9054
9055 struct HelpColumns {
9056 std::string left;
9057 std::string right;
9058 };
9059
9060 template<typename T>
9061 inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
9062 std::stringstream ss;
9063 ss << source;
9064 ss >> target;
9065 if( ss.fail() )
9066 return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
9067 else
9068 return ParserResult::ok( ParseResultType::Matched );
9069 }
9070 inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
9071 target = source;
9072 return ParserResult::ok( ParseResultType::Matched );
9073 }
9074 inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
9075 std::string srcLC = source;
9076 std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( unsigned char c ) { return static_cast<char>( std::tolower(c) ); } );
9077 if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
9078 target = true;
9079 else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
9080 target = false;
9081 else
9082 return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
9083 return ParserResult::ok( ParseResultType::Matched );
9084 }
9085 #ifdef CLARA_CONFIG_OPTIONAL_TYPE
9086 template<typename T>
9087 inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
9088 T temp;
9089 auto result = convertInto( source, temp );
9090 if( result )
9091 target = std::move(temp);
9092 return result;
9093 }
9094 #endif // CLARA_CONFIG_OPTIONAL_TYPE
9095
9096 struct NonCopyable {
9097 NonCopyable() = default;
9098 NonCopyable( NonCopyable const & ) = delete;
9099 NonCopyable( NonCopyable && ) = delete;
9100 NonCopyable &operator=( NonCopyable const & ) = delete;
9101 NonCopyable &operator=( NonCopyable && ) = delete;
9102 };
9103
9104 struct BoundRef : NonCopyable {
9105 virtual ~BoundRef() = default;
9106 virtual auto isContainer() const -> bool { return false; }
9107 virtual auto isFlag() const -> bool { return false; }
9108 };
9109 struct BoundValueRefBase : BoundRef {
9110 virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
9111 };
9112 struct BoundFlagRefBase : BoundRef {
9113 virtual auto setFlag( bool flag ) -> ParserResult = 0;
9114 virtual auto isFlag() const -> bool { return true; }
9115 };
9116
9117 template<typename T>
9118 struct BoundValueRef : BoundValueRefBase {
9119 T &m_ref;
9120
9121 explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
9122
9123 auto setValue( std::string const &arg ) -> ParserResult override {
9124 return convertInto( arg, m_ref );
9125 }
9126 };
9127
9128 template<typename T>
9129 struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
9130 std::vector<T> &m_ref;
9131
9132 explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
9133
9134 auto isContainer() const -> bool override { return true; }
9135
9136 auto setValue( std::string const &arg ) -> ParserResult override {
9137 T temp;
9138 auto result = convertInto( arg, temp );
9139 if( result )
9140 m_ref.push_back( temp );
9141 return result;
9142 }
9143 };
9144
9145 struct BoundFlagRef : BoundFlagRefBase {
9146 bool &m_ref;
9147
9148 explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
9149
9150 auto setFlag( bool flag ) -> ParserResult override {
9151 m_ref = flag;
9152 return ParserResult::ok( ParseResultType::Matched );
9153 }
9154 };
9155
9156 template<typename ReturnType>
9157 struct LambdaInvoker {
9158 static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
9159
9160 template<typename L, typename ArgType>
9161 static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
9162 return lambda( arg );
9163 }
9164 };
9165
9166 template<>
9167 struct LambdaInvoker<void> {
9168 template<typename L, typename ArgType>
9169 static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
9170 lambda( arg );
9171 return ParserResult::ok( ParseResultType::Matched );
9172 }
9173 };
9174
9175 template<typename ArgType, typename L>
9176 inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
9177 ArgType temp{};
9178 auto result = convertInto( arg, temp );
9179 return !result
9180 ? result
9181 : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
9182 }
9183
9184 template<typename L>
9185 struct BoundLambda : BoundValueRefBase {
9186 L m_lambda;
9187
9188 static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
9189 explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
9190
9191 auto setValue( std::string const &arg ) -> ParserResult override {
9192 return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
9193 }
9194 };
9195
9196 template<typename L>
9197 struct BoundFlagLambda : BoundFlagRefBase {
9198 L m_lambda;
9199
9200 static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
9201 static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
9202
9203 explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
9204
9205 auto setFlag( bool flag ) -> ParserResult override {
9206 return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
9207 }
9208 };
9209
9210 enum class Optionality { Optional, Required };
9211
9212 struct Parser;
9213
9214 class ParserBase {
9215 public:
9216 virtual ~ParserBase() = default;
9217 virtual auto validate() const -> Result { return Result::ok(); }
9218 virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult = 0;
9219 virtual auto cardinality() const -> size_t { return 1; }
9220
9221 auto parse( Args const &args ) const -> InternalParseResult {
9222 return parse( args.exeName(), TokenStream( args ) );
9223 }
9224 };
9225
9226 template<typename DerivedT>
9227 class ComposableParserImpl : public ParserBase {
9228 public:
9229 template<typename T>
9230 auto operator|( T const &other ) const -> Parser;
9231
9232 template<typename T>
9233 auto operator+( T const &other ) const -> Parser;
9234 };
9235
9236 // Common code and state for Args and Opts
9237 template<typename DerivedT>
9238 class ParserRefImpl : public ComposableParserImpl<DerivedT> {
9239 protected:
9240 Optionality m_optionality = Optionality::Optional;
9241 std::shared_ptr<BoundRef> m_ref;
9242 std::string m_hint;
9243 std::string m_description;
9244
9245 explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
9246
9247 public:
9248 template<typename T>
9249 ParserRefImpl( T &ref, std::string const &hint )
9250 : m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
9251 m_hint( hint )
9252 {}
9253
9254 template<typename LambdaT>
9255 ParserRefImpl( LambdaT const &ref, std::string const &hint )
9256 : m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
9257 m_hint(hint)
9258 {}
9259
9260 auto operator()( std::string const &description ) -> DerivedT & {
9261 m_description = description;
9262 return static_cast<DerivedT &>( *this );
9263 }
9264
9265 auto optional() -> DerivedT & {
9266 m_optionality = Optionality::Optional;
9267 return static_cast<DerivedT &>( *this );
9268 };
9269
9270 auto required() -> DerivedT & {
9271 m_optionality = Optionality::Required;
9272 return static_cast<DerivedT &>( *this );
9273 };
9274
9275 auto isOptional() const -> bool {
9276 return m_optionality == Optionality::Optional;
9277 }
9278
9279 auto cardinality() const -> size_t override {
9280 if( m_ref->isContainer() )
9281 return 0;
9282 else
9283 return 1;
9284 }
9285
9286 auto hint() const -> std::string { return m_hint; }
9287 };
9288
9289 class ExeName : public ComposableParserImpl<ExeName> {
9290 std::shared_ptr<std::string> m_name;
9291 std::shared_ptr<BoundValueRefBase> m_ref;
9292
9293 template<typename LambdaT>
9294 static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
9295 return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
9296 }
9297
9298 public:
9299 ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
9300
9301 explicit ExeName( std::string &ref ) : ExeName() {
9302 m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
9303 }
9304
9305 template<typename LambdaT>
9306 explicit ExeName( LambdaT const& lambda ) : ExeName() {
9307 m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
9308 }
9309
9310 // The exe name is not parsed out of the normal tokens, but is handled specially
9311 auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
9312 return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
9313 }
9314
9315 auto name() const -> std::string { return *m_name; }
9316 auto set( std::string const& newName ) -> ParserResult {
9317
9318 auto lastSlash = newName.find_last_of( "\\/" );
9319 auto filename = ( lastSlash == std::string::npos )
9320 ? newName
9321 : newName.substr( lastSlash+1 );
9322
9323 *m_name = filename;
9324 if( m_ref )
9325 return m_ref->setValue( filename );
9326 else
9327 return ParserResult::ok( ParseResultType::Matched );
9328 }
9329 };
9330
9331 class Arg : public ParserRefImpl<Arg> {
9332 public:
9333 using ParserRefImpl::ParserRefImpl;
9334
9335 auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
9336 auto validationResult = validate();
9337 if( !validationResult )
9338 return InternalParseResult( validationResult );
9339
9340 auto remainingTokens = tokens;
9341 auto const &token = *remainingTokens;
9342 if( token.type != TokenType::Argument )
9343 return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
9344
9345 assert( !m_ref->isFlag() );
9346 auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
9347
9348 auto result = valueRef->setValue( remainingTokens->token );
9349 if( !result )
9350 return InternalParseResult( result );
9351 else
9352 return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
9353 }
9354 };
9355
9356 inline auto normaliseOpt( std::string const &optName ) -> std::string {
9357 #ifdef CATCH_PLATFORM_WINDOWS
9358 if( optName[0] == '/' )
9359 return "-" + optName.substr( 1 );
9360 else
9361 #endif
9362 return optName;
9363 }
9364
9365 class Opt : public ParserRefImpl<Opt> {
9366 protected:
9367 std::vector<std::string> m_optNames;
9368
9369 public:
9370 template<typename LambdaT>
9371 explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
9372
9373 explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
9374
9375 template<typename LambdaT>
9376 Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
9377
9378 template<typename T>
9379 Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
9380
9381 auto operator[]( std::string const &optName ) -> Opt & {
9382 m_optNames.push_back( optName );
9383 return *this;
9384 }
9385
9386 auto getHelpColumns() const -> std::vector<HelpColumns> {
9387 std::ostringstream oss;
9388 bool first = true;
9389 for( auto const &opt : m_optNames ) {
9390 if (first)
9391 first = false;
9392 else
9393 oss << ", ";
9394 oss << opt;
9395 }
9396 if( !m_hint.empty() )
9397 oss << " <" << m_hint << ">";
9398 return { { oss.str(), m_description } };
9399 }
9400
9401 auto isMatch( std::string const &optToken ) const -> bool {
9402 auto normalisedToken = normaliseOpt( optToken );
9403 for( auto const &name : m_optNames ) {
9404 if( normaliseOpt( name ) == normalisedToken )
9405 return true;
9406 }
9407 return false;
9408 }
9409
9410 using ParserBase::parse;
9411
9412 auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
9413 auto validationResult = validate();
9414 if( !validationResult )
9415 return InternalParseResult( validationResult );
9416
9417 auto remainingTokens = tokens;
9418 if( remainingTokens && remainingTokens->type == TokenType::Option ) {
9419 auto const &token = *remainingTokens;
9420 if( isMatch(token.token ) ) {
9421 if( m_ref->isFlag() ) {
9422 auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
9423 auto result = flagRef->setFlag( true );
9424 if( !result )
9425 return InternalParseResult( result );
9426 if( result.value() == ParseResultType::ShortCircuitAll )
9427 return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
9428 } else {
9429 auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
9430 ++remainingTokens;
9431 if( !remainingTokens )
9432 return InternalParseResult::runtimeError( "Expected argument following " + token.token );
9433 auto const &argToken = *remainingTokens;
9434 if( argToken.type != TokenType::Argument )
9435 return InternalParseResult::runtimeError( "Expected argument following " + token.token );
9436 auto result = valueRef->setValue( argToken.token );
9437 if( !result )
9438 return InternalParseResult( result );
9439 if( result.value() == ParseResultType::ShortCircuitAll )
9440 return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
9441 }
9442 return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
9443 }
9444 }
9445 return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
9446 }
9447
9448 auto validate() const -> Result override {
9449 if( m_optNames.empty() )
9450 return Result::logicError( "No options supplied to Opt" );
9451 for( auto const &name : m_optNames ) {
9452 if( name.empty() )
9453 return Result::logicError( "Option name cannot be empty" );
9454 #ifdef CATCH_PLATFORM_WINDOWS
9455 if( name[0] != '-' && name[0] != '/' )
9456 return Result::logicError( "Option name must begin with '-' or '/'" );
9457 #else
9458 if( name[0] != '-' )
9459 return Result::logicError( "Option name must begin with '-'" );
9460 #endif
9461 }
9462 return ParserRefImpl::validate();
9463 }
9464 };
9465
9466 struct Help : Opt {
9467 Help( bool &showHelpFlag )
9468 : Opt([&]( bool flag ) {
9469 showHelpFlag = flag;
9470 return ParserResult::ok( ParseResultType::ShortCircuitAll );
9471 })
9472 {
9473 static_cast<Opt &>( *this )
9474 ("display usage information")
9475 ["-?"]["-h"]["--help"]
9476 .optional();
9477 }
9478 };
9479
9480 struct Parser : ParserBase {
9481
9482 mutable ExeName m_exeName;
9483 std::vector<Opt> m_options;
9484 std::vector<Arg> m_args;
9485
9486 auto operator|=( ExeName const &exeName ) -> Parser & {
9487 m_exeName = exeName;
9488 return *this;
9489 }
9490
9491 auto operator|=( Arg const &arg ) -> Parser & {
9492 m_args.push_back(arg);
9493 return *this;
9494 }
9495
9496 auto operator|=( Opt const &opt ) -> Parser & {
9497 m_options.push_back(opt);
9498 return *this;
9499 }
9500
9501 auto operator|=( Parser const &other ) -> Parser & {
9502 m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
9503 m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
9504 return *this;
9505 }
9506
9507 template<typename T>
9508 auto operator|( T const &other ) const -> Parser {
9509 return Parser( *this ) |= other;
9510 }
9511
9512 // Forward deprecated interface with '+' instead of '|'
9513 template<typename T>
9514 auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
9515 template<typename T>
9516 auto operator+( T const &other ) const -> Parser { return operator|( other ); }
9517
9518 auto getHelpColumns() const -> std::vector<HelpColumns> {
9519 std::vector<HelpColumns> cols;
9520 for (auto const &o : m_options) {
9521 auto childCols = o.getHelpColumns();
9522 cols.insert( cols.end(), childCols.begin(), childCols.end() );
9523 }
9524 return cols;
9525 }
9526
9527 void writeToStream( std::ostream &os ) const {
9528 if (!m_exeName.name().empty()) {
9529 os << "usage:\n" << " " << m_exeName.name() << " ";
9530 bool required = true, first = true;
9531 for( auto const &arg : m_args ) {
9532 if (first)
9533 first = false;
9534 else
9535 os << " ";
9536 if( arg.isOptional() && required ) {
9537 os << "[";
9538 required = false;
9539 }
9540 os << "<" << arg.hint() << ">";
9541 if( arg.cardinality() == 0 )
9542 os << " ... ";
9543 }
9544 if( !required )
9545 os << "]";
9546 if( !m_options.empty() )
9547 os << " options";
9548 os << "\n\nwhere options are:" << std::endl;
9549 }
9550
9551 auto rows = getHelpColumns();
9552 size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
9553 size_t optWidth = 0;
9554 for( auto const &cols : rows )
9555 optWidth = (std::max)(optWidth, cols.left.size() + 2);
9556
9557 optWidth = (std::min)(optWidth, consoleWidth/2);
9558
9559 for( auto const &cols : rows ) {
9560 auto row =
9561 TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
9562 TextFlow::Spacer(4) +
9563 TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
9564 os << row << std::endl;
9565 }
9566 }
9567
9568 friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
9569 parser.writeToStream( os );
9570 return os;
9571 }
9572
9573 auto validate() const -> Result override {
9574 for( auto const &opt : m_options ) {
9575 auto result = opt.validate();
9576 if( !result )
9577 return result;
9578 }
9579 for( auto const &arg : m_args ) {
9580 auto result = arg.validate();
9581 if( !result )
9582 return result;
9583 }
9584 return Result::ok();
9585 }
9586
9587 using ParserBase::parse;
9588
9589 auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
9590
9591 struct ParserInfo {
9592 ParserBase const* parser = nullptr;
9593 size_t count = 0;
9594 };
9595 const size_t totalParsers = m_options.size() + m_args.size();
9596 assert( totalParsers < 512 );
9597 // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
9598 ParserInfo parseInfos[512];
9599
9600 {
9601 size_t i = 0;
9602 for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
9603 for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
9604 }
9605
9606 m_exeName.set( exeName );
9607
9608 auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
9609 while( result.value().remainingTokens() ) {
9610 bool tokenParsed = false;
9611
9612 for( size_t i = 0; i < totalParsers; ++i ) {
9613 auto& parseInfo = parseInfos[i];
9614 if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
9615 result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
9616 if (!result)
9617 return result;
9618 if (result.value().type() != ParseResultType::NoMatch) {
9619 tokenParsed = true;
9620 ++parseInfo.count;
9621 break;
9622 }
9623 }
9624 }
9625
9626 if( result.value().type() == ParseResultType::ShortCircuitAll )
9627 return result;
9628 if( !tokenParsed )
9629 return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
9630 }
9631 // !TBD Check missing required options
9632 return result;
9633 }
9634 };
9635
9636 template<typename DerivedT>
9637 template<typename T>
9638 auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
9639 return Parser() | static_cast<DerivedT const &>( *this ) | other;
9640 }
9641 } // namespace detail
9642
9643 // A Combined parser
9644 using detail::Parser;
9645
9646 // A parser for options
9647 using detail::Opt;
9648
9649 // A parser for arguments
9650 using detail::Arg;
9651
9652 // Wrapper for argc, argv from main()
9653 using detail::Args;
9654
9655 // Specifies the name of the executable
9656 using detail::ExeName;
9657
9658 // Convenience wrapper for option parser that specifies the help option
9659 using detail::Help;
9660
9661 // enum of result types from a parse
9662 using detail::ParseResultType;
9663
9664 // Result type for parser operation
9665 using detail::ParserResult;
9666
9667 }} // namespace Catch::clara
9668
9669 // end clara.hpp
9670 #ifdef __clang__
9671 #pragma clang diagnostic pop
9672 #endif
9673
9674 // Restore Clara's value for console width, if present
9675 #ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
9676 #define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
9677 #undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
9678 #endif
9679
9680 // end catch_clara.h
9681 namespace Catch {
9682
9683 clara::Parser makeCommandLineParser( ConfigData& config );
9684
9685 } // end namespace Catch
9686
9687 // end catch_commandline.h
9688 #include <fstream>
9689 #include <ctime>
9690
9691 namespace Catch {
9692
9693 clara::Parser makeCommandLineParser( ConfigData& config ) {
9694
9695 using namespace clara;
9696
9697 auto const setWarning = [&]( std::string const& warning ) {
9698 auto warningSet = [&]() {
9699 if( warning == "NoAssertions" )
9700 return WarnAbout::NoAssertions;
9701
9702 if ( warning == "NoTests" )
9703 return WarnAbout::NoTests;
9704
9705 return WarnAbout::Nothing;
9706 }();
9707
9708 if (warningSet == WarnAbout::Nothing)
9709 return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
9710 config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
9711 return ParserResult::ok( ParseResultType::Matched );
9712 };
9713 auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
9714 std::ifstream f( filename.c_str() );
9715 if( !f.is_open() )
9716 return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
9717
9718 std::string line;
9719 while( std::getline( f, line ) ) {
9720 line = trim(line);
9721 if( !line.empty() && !startsWith( line, '#' ) ) {
9722 if( !startsWith( line, '"' ) )
9723 line = '"' + line + '"';
9724 config.testsOrTags.push_back( line );
9725 config.testsOrTags.emplace_back( "," );
9726 }
9727 }
9728 //Remove comma in the end
9729 if(!config.testsOrTags.empty())
9730 config.testsOrTags.erase( config.testsOrTags.end()-1 );
9731
9732 return ParserResult::ok( ParseResultType::Matched );
9733 };
9734 auto const setTestOrder = [&]( std::string const& order ) {
9735 if( startsWith( "declared", order ) )
9736 config.runOrder = RunTests::InDeclarationOrder;
9737 else if( startsWith( "lexical", order ) )
9738 config.runOrder = RunTests::InLexicographicalOrder;
9739 else if( startsWith( "random", order ) )
9740 config.runOrder = RunTests::InRandomOrder;
9741 else
9742 return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
9743 return ParserResult::ok( ParseResultType::Matched );
9744 };
9745 auto const setRngSeed = [&]( std::string const& seed ) {
9746 if( seed != "time" )
9747 return clara::detail::convertInto( seed, config.rngSeed );
9748 config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
9749 return ParserResult::ok( ParseResultType::Matched );
9750 };
9751 auto const setColourUsage = [&]( std::string const& useColour ) {
9752 auto mode = toLower( useColour );
9753
9754 if( mode == "yes" )
9755 config.useColour = UseColour::Yes;
9756 else if( mode == "no" )
9757 config.useColour = UseColour::No;
9758 else if( mode == "auto" )
9759 config.useColour = UseColour::Auto;
9760 else
9761 return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
9762 return ParserResult::ok( ParseResultType::Matched );
9763 };
9764 auto const setWaitForKeypress = [&]( std::string const& keypress ) {
9765 auto keypressLc = toLower( keypress );
9766 if (keypressLc == "never")
9767 config.waitForKeypress = WaitForKeypress::Never;
9768 else if( keypressLc == "start" )
9769 config.waitForKeypress = WaitForKeypress::BeforeStart;
9770 else if( keypressLc == "exit" )
9771 config.waitForKeypress = WaitForKeypress::BeforeExit;
9772 else if( keypressLc == "both" )
9773 config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
9774 else
9775 return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
9776 return ParserResult::ok( ParseResultType::Matched );
9777 };
9778 auto const setVerbosity = [&]( std::string const& verbosity ) {
9779 auto lcVerbosity = toLower( verbosity );
9780 if( lcVerbosity == "quiet" )
9781 config.verbosity = Verbosity::Quiet;
9782 else if( lcVerbosity == "normal" )
9783 config.verbosity = Verbosity::Normal;
9784 else if( lcVerbosity == "high" )
9785 config.verbosity = Verbosity::High;
9786 else
9787 return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
9788 return ParserResult::ok( ParseResultType::Matched );
9789 };
9790 auto const setReporter = [&]( std::string const& reporter ) {
9791 IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
9792
9793 auto lcReporter = toLower( reporter );
9794 auto result = factories.find( lcReporter );
9795
9796 if( factories.end() != result )
9797 config.reporterName = lcReporter;
9798 else
9799 return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
9800 return ParserResult::ok( ParseResultType::Matched );
9801 };
9802
9803 auto cli
9804 = ExeName( config.processName )
9805 | Help( config.showHelp )
9806 | Opt( config.listTests )
9807 ["-l"]["--list-tests"]
9808 ( "list all/matching test cases" )
9809 | Opt( config.listTags )
9810 ["-t"]["--list-tags"]
9811 ( "list all/matching tags" )
9812 | Opt( config.showSuccessfulTests )
9813 ["-s"]["--success"]
9814 ( "include successful tests in output" )
9815 | Opt( config.shouldDebugBreak )
9816 ["-b"]["--break"]
9817 ( "break into debugger on failure" )
9818 | Opt( config.noThrow )
9819 ["-e"]["--nothrow"]
9820 ( "skip exception tests" )
9821 | Opt( config.showInvisibles )
9822 ["-i"]["--invisibles"]
9823 ( "show invisibles (tabs, newlines)" )
9824 | Opt( config.outputFilename, "filename" )
9825 ["-o"]["--out"]
9826 ( "output filename" )
9827 | Opt( setReporter, "name" )
9828 ["-r"]["--reporter"]
9829 ( "reporter to use (defaults to console)" )
9830 | Opt( config.name, "name" )
9831 ["-n"]["--name"]
9832 ( "suite name" )
9833 | Opt( [&]( bool ){ config.abortAfter = 1; } )
9834 ["-a"]["--abort"]
9835 ( "abort at first failure" )
9836 | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
9837 ["-x"]["--abortx"]
9838 ( "abort after x failures" )
9839 | Opt( setWarning, "warning name" )
9840 ["-w"]["--warn"]
9841 ( "enable warnings" )
9842 | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
9843 ["-d"]["--durations"]
9844 ( "show test durations" )
9845 | Opt( config.minDuration, "seconds" )
9846 ["-D"]["--min-duration"]
9847 ( "show test durations for tests taking at least the given number of seconds" )
9848 | Opt( loadTestNamesFromFile, "filename" )
9849 ["-f"]["--input-file"]
9850 ( "load test names to run from a file" )
9851 | Opt( config.filenamesAsTags )
9852 ["-#"]["--filenames-as-tags"]
9853 ( "adds a tag for the filename" )
9854 | Opt( config.sectionsToRun, "section name" )
9855 ["-c"]["--section"]
9856 ( "specify section to run" )
9857 | Opt( setVerbosity, "quiet|normal|high" )
9858 ["-v"]["--verbosity"]
9859 ( "set output verbosity" )
9860 | Opt( config.listTestNamesOnly )
9861 ["--list-test-names-only"]
9862 ( "list all/matching test cases names only" )
9863 | Opt( config.listReporters )
9864 ["--list-reporters"]
9865 ( "list all reporters" )
9866 | Opt( setTestOrder, "decl|lex|rand" )
9867 ["--order"]
9868 ( "test case order (defaults to decl)" )
9869 | Opt( setRngSeed, "'time'|number" )
9870 ["--rng-seed"]
9871 ( "set a specific seed for random numbers" )
9872 | Opt( setColourUsage, "yes|no" )
9873 ["--use-colour"]
9874 ( "should output be colourised" )
9875 | Opt( config.libIdentify )
9876 ["--libidentify"]
9877 ( "report name and version according to libidentify standard" )
9878 | Opt( setWaitForKeypress, "never|start|exit|both" )
9879 ["--wait-for-keypress"]
9880 ( "waits for a keypress before exiting" )
9881 | Opt( config.benchmarkSamples, "samples" )
9882 ["--benchmark-samples"]
9883 ( "number of samples to collect (default: 100)" )
9884 | Opt( config.benchmarkResamples, "resamples" )
9885 ["--benchmark-resamples"]
9886 ( "number of resamples for the bootstrap (default: 100000)" )
9887 | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
9888 ["--benchmark-confidence-interval"]
9889 ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
9890 | Opt( config.benchmarkNoAnalysis )
9891 ["--benchmark-no-analysis"]
9892 ( "perform only measurements; do not perform any analysis" )
9893 | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
9894 ["--benchmark-warmup-time"]
9895 ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
9896 | Arg( config.testsOrTags, "test name|pattern|tags" )
9897 ( "which test or tests to use" );
9898
9899 return cli;
9900 }
9901
9902 } // end namespace Catch
9903 // end catch_commandline.cpp
9904 // start catch_common.cpp
9905
9906 #include <cstring>
9907 #include <ostream>
9908
9909 namespace Catch {
9910
9911 bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
9912 return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
9913 }
9914 bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
9915 // We can assume that the same file will usually have the same pointer.
9916 // Thus, if the pointers are the same, there is no point in calling the strcmp
9917 return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
9918 }
9919
9920 std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
9921 #ifndef __GNUG__
9922 os << info.file << '(' << info.line << ')';
9923 #else
9924 os << info.file << ':' << info.line;
9925 #endif
9926 return os;
9927 }
9928
9929 std::string StreamEndStop::operator+() const {
9930 return std::string();
9931 }
9932
9933 NonCopyable::NonCopyable() = default;
9934 NonCopyable::~NonCopyable() = default;
9935
9936 }
9937 // end catch_common.cpp
9938 // start catch_config.cpp
9939
9940 namespace Catch {
9941
9942 Config::Config( ConfigData const& data )
9943 : m_data( data ),
9944 m_stream( openStream() )
9945 {
9946 // We need to trim filter specs to avoid trouble with superfluous
9947 // whitespace (esp. important for bdd macros, as those are manually
9948 // aligned with whitespace).
9949
9950 for (auto& elem : m_data.testsOrTags) {
9951 elem = trim(elem);
9952 }
9953 for (auto& elem : m_data.sectionsToRun) {
9954 elem = trim(elem);
9955 }
9956
9957 TestSpecParser parser(ITagAliasRegistry::get());
9958 if (!m_data.testsOrTags.empty()) {
9959 m_hasTestFilters = true;
9960 for (auto const& testOrTags : m_data.testsOrTags) {
9961 parser.parse(testOrTags);
9962 }
9963 }
9964 m_testSpec = parser.testSpec();
9965 }
9966
9967 std::string const& Config::getFilename() const {
9968 return m_data.outputFilename ;
9969 }
9970
9971 bool Config::listTests() const { return m_data.listTests; }
9972 bool Config::listTestNamesOnly() const { return m_data.listTestNamesOnly; }
9973 bool Config::listTags() const { return m_data.listTags; }
9974 bool Config::listReporters() const { return m_data.listReporters; }
9975
9976 std::string Config::getProcessName() const { return m_data.processName; }
9977 std::string const& Config::getReporterName() const { return m_data.reporterName; }
9978
9979 std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
9980 std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
9981
9982 TestSpec const& Config::testSpec() const { return m_testSpec; }
9983 bool Config::hasTestFilters() const { return m_hasTestFilters; }
9984
9985 bool Config::showHelp() const { return m_data.showHelp; }
9986
9987 // IConfig interface
9988 bool Config::allowThrows() const { return !m_data.noThrow; }
9989 std::ostream& Config::stream() const { return m_stream->stream(); }
9990 std::string Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
9991 bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; }
9992 bool Config::warnAboutMissingAssertions() const { return !!(m_data.warnings & WarnAbout::NoAssertions); }
9993 bool Config::warnAboutNoTests() const { return !!(m_data.warnings & WarnAbout::NoTests); }
9994 ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
9995 double Config::minDuration() const { return m_data.minDuration; }
9996 RunTests::InWhatOrder Config::runOrder() const { return m_data.runOrder; }
9997 unsigned int Config::rngSeed() const { return m_data.rngSeed; }
9998 UseColour::YesOrNo Config::useColour() const { return m_data.useColour; }
9999 bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; }
10000 int Config::abortAfter() const { return m_data.abortAfter; }
10001 bool Config::showInvisibles() const { return m_data.showInvisibles; }
10002 Verbosity Config::verbosity() const { return m_data.verbosity; }
10003
10004 bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; }
10005 int Config::benchmarkSamples() const { return m_data.benchmarkSamples; }
10006 double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
10007 unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
10008 std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
10009
10010 IStream const* Config::openStream() {
10011 return Catch::makeStream(m_data.outputFilename);
10012 }
10013
10014 } // end namespace Catch
10015 // end catch_config.cpp
10016 // start catch_console_colour.cpp
10017
10018 #if defined(__clang__)
10019 # pragma clang diagnostic push
10020 # pragma clang diagnostic ignored "-Wexit-time-destructors"
10021 #endif
10022
10023 // start catch_errno_guard.h
10024
10025 namespace Catch {
10026
10027 class ErrnoGuard {
10028 public:
10029 ErrnoGuard();
10030 ~ErrnoGuard();
10031 private:
10032 int m_oldErrno;
10033 };
10034
10035 }
10036
10037 // end catch_errno_guard.h
10038 // start catch_windows_h_proxy.h
10039
10040
10041 #if defined(CATCH_PLATFORM_WINDOWS)
10042
10043 #if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
10044 # define CATCH_DEFINED_NOMINMAX
10045 # define NOMINMAX
10046 #endif
10047 #if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
10048 # define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
10049 # define WIN32_LEAN_AND_MEAN
10050 #endif
10051
10052 #ifdef __AFXDLL
10053 #include <AfxWin.h>
10054 #else
10055 #include <windows.h>
10056 #endif
10057
10058 #ifdef CATCH_DEFINED_NOMINMAX
10059 # undef NOMINMAX
10060 #endif
10061 #ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
10062 # undef WIN32_LEAN_AND_MEAN
10063 #endif
10064
10065 #endif // defined(CATCH_PLATFORM_WINDOWS)
10066
10067 // end catch_windows_h_proxy.h
10068 #include <sstream>
10069
10070 namespace Catch {
10071 namespace {
10072
10073 struct IColourImpl {
10074 virtual ~IColourImpl() = default;
10075 virtual void use( Colour::Code _colourCode ) = 0;
10076 };
10077
10078 struct NoColourImpl : IColourImpl {
10079 void use( Colour::Code ) override {}
10080
10081 static IColourImpl* instance() {
10082 static NoColourImpl s_instance;
10083 return &s_instance;
10084 }
10085 };
10086
10087 } // anon namespace
10088 } // namespace Catch
10089
10090 #if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
10091 # ifdef CATCH_PLATFORM_WINDOWS
10092 # define CATCH_CONFIG_COLOUR_WINDOWS
10093 # else
10094 # define CATCH_CONFIG_COLOUR_ANSI
10095 # endif
10096 #endif
10097
10098 #if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
10099
10100 namespace Catch {
10101 namespace {
10102
10103 class Win32ColourImpl : public IColourImpl {
10104 public:
10105 Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
10106 {
10107 CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
10108 GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
10109 originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
10110 originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
10111 }
10112
10113 void use( Colour::Code _colourCode ) override {
10114 switch( _colourCode ) {
10115 case Colour::None: return setTextAttribute( originalForegroundAttributes );
10116 case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
10117 case Colour::Red: return setTextAttribute( FOREGROUND_RED );
10118 case Colour::Green: return setTextAttribute( FOREGROUND_GREEN );
10119 case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE );
10120 case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
10121 case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
10122 case Colour::Grey: return setTextAttribute( 0 );
10123
10124 case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY );
10125 case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
10126 case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
10127 case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
10128 case Colour::BrightYellow: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
10129
10130 case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
10131
10132 default:
10133 CATCH_ERROR( "Unknown colour requested" );
10134 }
10135 }
10136
10137 private:
10138 void setTextAttribute( WORD _textAttribute ) {
10139 SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes );
10140 }
10141 HANDLE stdoutHandle;
10142 WORD originalForegroundAttributes;
10143 WORD originalBackgroundAttributes;
10144 };
10145
10146 IColourImpl* platformColourInstance() {
10147 static Win32ColourImpl s_instance;
10148
10149 IConfigPtr config = getCurrentContext().getConfig();
10150 UseColour::YesOrNo colourMode = config
10151 ? config->useColour()
10152 : UseColour::Auto;
10153 if( colourMode == UseColour::Auto )
10154 colourMode = UseColour::Yes;
10155 return colourMode == UseColour::Yes
10156 ? &s_instance
10157 : NoColourImpl::instance();
10158 }
10159
10160 } // end anon namespace
10161 } // end namespace Catch
10162
10163 #elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
10164
10165 #include <unistd.h>
10166
10167 namespace Catch {
10168 namespace {
10169
10170 // use POSIX/ ANSI console terminal codes
10171 // Thanks to Adam Strzelecki for original contribution
10172 // (http://github.com/nanoant)
10173 // https://github.com/philsquared/Catch/pull/131
10174 class PosixColourImpl : public IColourImpl {
10175 public:
10176 void use( Colour::Code _colourCode ) override {
10177 switch( _colourCode ) {
10178 case Colour::None:
10179 case Colour::White: return setColour( "[0m" );
10180 case Colour::Red: return setColour( "[0;31m" );
10181 case Colour::Green: return setColour( "[0;32m" );
10182 case Colour::Blue: return setColour( "[0;34m" );
10183 case Colour::Cyan: return setColour( "[0;36m" );
10184 case Colour::Yellow: return setColour( "[0;33m" );
10185 case Colour::Grey: return setColour( "[1;30m" );
10186
10187 case Colour::LightGrey: return setColour( "[0;37m" );
10188 case Colour::BrightRed: return setColour( "[1;31m" );
10189 case Colour::BrightGreen: return setColour( "[1;32m" );
10190 case Colour::BrightWhite: return setColour( "[1;37m" );
10191 case Colour::BrightYellow: return setColour( "[1;33m" );
10192
10193 case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
10194 default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
10195 }
10196 }
10197 static IColourImpl* instance() {
10198 static PosixColourImpl s_instance;
10199 return &s_instance;
10200 }
10201
10202 private:
10203 void setColour( const char* _escapeCode ) {
10204 getCurrentContext().getConfig()->stream()
10205 << '\033' << _escapeCode;
10206 }
10207 };
10208
10209 bool useColourOnPlatform() {
10210 return
10211 #if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
10212 !isDebuggerActive() &&
10213 #endif
10214 #if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
10215 isatty(STDOUT_FILENO)
10216 #else
10217 false
10218 #endif
10219 ;
10220 }
10221 IColourImpl* platformColourInstance() {
10222 ErrnoGuard guard;
10223 IConfigPtr config = getCurrentContext().getConfig();
10224 UseColour::YesOrNo colourMode = config
10225 ? config->useColour()
10226 : UseColour::Auto;
10227 if( colourMode == UseColour::Auto )
10228 colourMode = useColourOnPlatform()
10229 ? UseColour::Yes
10230 : UseColour::No;
10231 return colourMode == UseColour::Yes
10232 ? PosixColourImpl::instance()
10233 : NoColourImpl::instance();
10234 }
10235
10236 } // end anon namespace
10237 } // end namespace Catch
10238
10239 #else // not Windows or ANSI ///////////////////////////////////////////////
10240
10241 namespace Catch {
10242
10243 static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
10244
10245 } // end namespace Catch
10246
10247 #endif // Windows/ ANSI/ None
10248
10249 namespace Catch {
10250
10251 Colour::Colour( Code _colourCode ) { use( _colourCode ); }
10252 Colour::Colour( Colour&& other ) noexcept {
10253 m_moved = other.m_moved;
10254 other.m_moved = true;
10255 }
10256 Colour& Colour::operator=( Colour&& other ) noexcept {
10257 m_moved = other.m_moved;
10258 other.m_moved = true;
10259 return *this;
10260 }
10261
10262 Colour::~Colour(){ if( !m_moved ) use( None ); }
10263
10264 void Colour::use( Code _colourCode ) {
10265 static IColourImpl* impl = platformColourInstance();
10266 // Strictly speaking, this cannot possibly happen.
10267 // However, under some conditions it does happen (see #1626),
10268 // and this change is small enough that we can let practicality
10269 // triumph over purity in this case.
10270 if (impl != nullptr) {
10271 impl->use( _colourCode );
10272 }
10273 }
10274
10275 std::ostream& operator << ( std::ostream& os, Colour const& ) {
10276 return os;
10277 }
10278
10279 } // end namespace Catch
10280
10281 #if defined(__clang__)
10282 # pragma clang diagnostic pop
10283 #endif
10284
10285 // end catch_console_colour.cpp
10286 // start catch_context.cpp
10287
10288 namespace Catch {
10289
10290 class Context : public IMutableContext, NonCopyable {
10291
10292 public: // IContext
10293 IResultCapture* getResultCapture() override {
10294 return m_resultCapture;
10295 }
10296 IRunner* getRunner() override {
10297 return m_runner;
10298 }
10299
10300 IConfigPtr const& getConfig() const override {
10301 return m_config;
10302 }
10303
10304 ~Context() override;
10305
10306 public: // IMutableContext
10307 void setResultCapture( IResultCapture* resultCapture ) override {
10308 m_resultCapture = resultCapture;
10309 }
10310 void setRunner( IRunner* runner ) override {
10311 m_runner = runner;
10312 }
10313 void setConfig( IConfigPtr const& config ) override {
10314 m_config = config;
10315 }
10316
10317 friend IMutableContext& getCurrentMutableContext();
10318
10319 private:
10320 IConfigPtr m_config;
10321 IRunner* m_runner = nullptr;
10322 IResultCapture* m_resultCapture = nullptr;
10323 };
10324
10325 IMutableContext *IMutableContext::currentContext = nullptr;
10326
10327 void IMutableContext::createContext()
10328 {
10329 currentContext = new Context();
10330 }
10331
10332 void cleanUpContext() {
10333 delete IMutableContext::currentContext;
10334 IMutableContext::currentContext = nullptr;
10335 }
10336 IContext::~IContext() = default;
10337 IMutableContext::~IMutableContext() = default;
10338 Context::~Context() = default;
10339
10340 SimplePcg32& rng() {
10341 static SimplePcg32 s_rng;
10342 return s_rng;
10343 }
10344
10345 }
10346 // end catch_context.cpp
10347 // start catch_debug_console.cpp
10348
10349 // start catch_debug_console.h
10350
10351 #include <string>
10352
10353 namespace Catch {
10354 void writeToDebugConsole( std::string const& text );
10355 }
10356
10357 // end catch_debug_console.h
10358 #if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
10359 #include <android/log.h>
10360
10361 namespace Catch {
10362 void writeToDebugConsole( std::string const& text ) {
10363 __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
10364 }
10365 }
10366
10367 #elif defined(CATCH_PLATFORM_WINDOWS)
10368
10369 namespace Catch {
10370 void writeToDebugConsole( std::string const& text ) {
10371 ::OutputDebugStringA( text.c_str() );
10372 }
10373 }
10374
10375 #else
10376
10377 namespace Catch {
10378 void writeToDebugConsole( std::string const& text ) {
10379 // !TBD: Need a version for Mac/ XCode and other IDEs
10380 Catch::cout() << text;
10381 }
10382 }
10383
10384 #endif // Platform
10385 // end catch_debug_console.cpp
10386 // start catch_debugger.cpp
10387
10388 #if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
10389
10390 # include <cassert>
10391 # include <sys/types.h>
10392 # include <unistd.h>
10393 # include <cstddef>
10394 # include <ostream>
10395
10396 #ifdef __apple_build_version__
10397 // These headers will only compile with AppleClang (XCode)
10398 // For other compilers (Clang, GCC, ... ) we need to exclude them
10399 # include <sys/sysctl.h>
10400 #endif
10401
10402 namespace Catch {
10403 #ifdef __apple_build_version__
10404 // The following function is taken directly from the following technical note:
10405 // https://developer.apple.com/library/archive/qa/qa1361/_index.html
10406
10407 // Returns true if the current process is being debugged (either
10408 // running under the debugger or has a debugger attached post facto).
10409 bool isDebuggerActive(){
10410 int mib[4];
10411 struct kinfo_proc info;
10412 std::size_t size;
10413
10414 // Initialize the flags so that, if sysctl fails for some bizarre
10415 // reason, we get a predictable result.
10416
10417 info.kp_proc.p_flag = 0;
10418
10419 // Initialize mib, which tells sysctl the info we want, in this case
10420 // we're looking for information about a specific process ID.
10421
10422 mib[0] = CTL_KERN;
10423 mib[1] = KERN_PROC;
10424 mib[2] = KERN_PROC_PID;
10425 mib[3] = getpid();
10426
10427 // Call sysctl.
10428
10429 size = sizeof(info);
10430 if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
10431 Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
10432 return false;
10433 }
10434
10435 // We're being debugged if the P_TRACED flag is set.
10436
10437 return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
10438 }
10439 #else
10440 bool isDebuggerActive() {
10441 // We need to find another way to determine this for non-appleclang compilers on macOS
10442 return false;
10443 }
10444 #endif
10445 } // namespace Catch
10446
10447 #elif defined(CATCH_PLATFORM_LINUX)
10448 #include <fstream>
10449 #include <string>
10450
10451 namespace Catch{
10452 // The standard POSIX way of detecting a debugger is to attempt to
10453 // ptrace() the process, but this needs to be done from a child and not
10454 // this process itself to still allow attaching to this process later
10455 // if wanted, so is rather heavy. Under Linux we have the PID of the
10456 // "debugger" (which doesn't need to be gdb, of course, it could also
10457 // be strace, for example) in /proc/$PID/status, so just get it from
10458 // there instead.
10459 bool isDebuggerActive(){
10460 // Libstdc++ has a bug, where std::ifstream sets errno to 0
10461 // This way our users can properly assert over errno values
10462 ErrnoGuard guard;
10463 std::ifstream in("/proc/self/status");
10464 for( std::string line; std::getline(in, line); ) {
10465 static const int PREFIX_LEN = 11;
10466 if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
10467 // We're traced if the PID is not 0 and no other PID starts
10468 // with 0 digit, so it's enough to check for just a single
10469 // character.
10470 return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
10471 }
10472 }
10473
10474 return false;
10475 }
10476 } // namespace Catch
10477 #elif defined(_MSC_VER)
10478 extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
10479 namespace Catch {
10480 bool isDebuggerActive() {
10481 return IsDebuggerPresent() != 0;
10482 }
10483 }
10484 #elif defined(__MINGW32__)
10485 extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
10486 namespace Catch {
10487 bool isDebuggerActive() {
10488 return IsDebuggerPresent() != 0;
10489 }
10490 }
10491 #else
10492 namespace Catch {
10493 bool isDebuggerActive() { return false; }
10494 }
10495 #endif // Platform
10496 // end catch_debugger.cpp
10497 // start catch_decomposer.cpp
10498
10499 namespace Catch {
10500
10501 ITransientExpression::~ITransientExpression() = default;
10502
10503 void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
10504 if( lhs.size() + rhs.size() < 40 &&
10505 lhs.find('\n') == std::string::npos &&
10506 rhs.find('\n') == std::string::npos )
10507 os << lhs << " " << op << " " << rhs;
10508 else
10509 os << lhs << "\n" << op << "\n" << rhs;
10510 }
10511 }
10512 // end catch_decomposer.cpp
10513 // start catch_enforce.cpp
10514
10515 #include <stdexcept>
10516
10517 namespace Catch {
10518 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
10519 [[noreturn]]
10520 void throw_exception(std::exception const& e) {
10521 Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
10522 << "The message was: " << e.what() << '\n';
10523 std::terminate();
10524 }
10525 #endif
10526
10527 [[noreturn]]
10528 void throw_logic_error(std::string const& msg) {
10529 throw_exception(std::logic_error(msg));
10530 }
10531
10532 [[noreturn]]
10533 void throw_domain_error(std::string const& msg) {
10534 throw_exception(std::domain_error(msg));
10535 }
10536
10537 [[noreturn]]
10538 void throw_runtime_error(std::string const& msg) {
10539 throw_exception(std::runtime_error(msg));
10540 }
10541
10542 } // namespace Catch;
10543 // end catch_enforce.cpp
10544 // start catch_enum_values_registry.cpp
10545 // start catch_enum_values_registry.h
10546
10547 #include <vector>
10548 #include <memory>
10549
10550 namespace Catch {
10551
10552 namespace Detail {
10553
10554 std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
10555
10556 class EnumValuesRegistry : public IMutableEnumValuesRegistry {
10557
10558 std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
10559
10560 EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
10561 };
10562
10563 std::vector<StringRef> parseEnums( StringRef enums );
10564
10565 } // Detail
10566
10567 } // Catch
10568
10569 // end catch_enum_values_registry.h
10570
10571 #include <map>
10572 #include <cassert>
10573
10574 namespace Catch {
10575
10576 IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
10577
10578 namespace Detail {
10579
10580 namespace {
10581 // Extracts the actual name part of an enum instance
10582 // In other words, it returns the Blue part of Bikeshed::Colour::Blue
10583 StringRef extractInstanceName(StringRef enumInstance) {
10584 // Find last occurrence of ":"
10585 size_t name_start = enumInstance.size();
10586 while (name_start > 0 && enumInstance[name_start - 1] != ':') {
10587 --name_start;
10588 }
10589 return enumInstance.substr(name_start, enumInstance.size() - name_start);
10590 }
10591 }
10592
10593 std::vector<StringRef> parseEnums( StringRef enums ) {
10594 auto enumValues = splitStringRef( enums, ',' );
10595 std::vector<StringRef> parsed;
10596 parsed.reserve( enumValues.size() );
10597 for( auto const& enumValue : enumValues ) {
10598 parsed.push_back(trim(extractInstanceName(enumValue)));
10599 }
10600 return parsed;
10601 }
10602
10603 EnumInfo::~EnumInfo() {}
10604
10605 StringRef EnumInfo::lookup( int value ) const {
10606 for( auto const& valueToName : m_values ) {
10607 if( valueToName.first == value )
10608 return valueToName.second;
10609 }
10610 return "{** unexpected enum value **}"_sr;
10611 }
10612
10613 std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
10614 std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
10615 enumInfo->m_name = enumName;
10616 enumInfo->m_values.reserve( values.size() );
10617
10618 const auto valueNames = Catch::Detail::parseEnums( allValueNames );
10619 assert( valueNames.size() == values.size() );
10620 std::size_t i = 0;
10621 for( auto value : values )
10622 enumInfo->m_values.emplace_back(value, valueNames[i++]);
10623
10624 return enumInfo;
10625 }
10626
10627 EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
10628 m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
10629 return *m_enumInfos.back();
10630 }
10631
10632 } // Detail
10633 } // Catch
10634
10635 // end catch_enum_values_registry.cpp
10636 // start catch_errno_guard.cpp
10637
10638 #include <cerrno>
10639
10640 namespace Catch {
10641 ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
10642 ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
10643 }
10644 // end catch_errno_guard.cpp
10645 // start catch_exception_translator_registry.cpp
10646
10647 // start catch_exception_translator_registry.h
10648
10649 #include <vector>
10650 #include <string>
10651 #include <memory>
10652
10653 namespace Catch {
10654
10655 class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
10656 public:
10657 ~ExceptionTranslatorRegistry();
10658 virtual void registerTranslator( const IExceptionTranslator* translator );
10659 std::string translateActiveException() const override;
10660 std::string tryTranslators() const;
10661
10662 private:
10663 std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
10664 };
10665 }
10666
10667 // end catch_exception_translator_registry.h
10668 #ifdef __OBJC__
10669 #import "Foundation/Foundation.h"
10670 #endif
10671
10672 namespace Catch {
10673
10674 ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
10675 }
10676
10677 void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
10678 m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
10679 }
10680
10681 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
10682 std::string ExceptionTranslatorRegistry::translateActiveException() const {
10683 try {
10684 #ifdef __OBJC__
10685 // In Objective-C try objective-c exceptions first
10686 @try {
10687 return tryTranslators();
10688 }
10689 @catch (NSException *exception) {
10690 return Catch::Detail::stringify( [exception description] );
10691 }
10692 #else
10693 // Compiling a mixed mode project with MSVC means that CLR
10694 // exceptions will be caught in (...) as well. However, these
10695 // do not fill-in std::current_exception and thus lead to crash
10696 // when attempting rethrow.
10697 // /EHa switch also causes structured exceptions to be caught
10698 // here, but they fill-in current_exception properly, so
10699 // at worst the output should be a little weird, instead of
10700 // causing a crash.
10701 if (std::current_exception() == nullptr) {
10702 return "Non C++ exception. Possibly a CLR exception.";
10703 }
10704 return tryTranslators();
10705 #endif
10706 }
10707 catch( TestFailureException& ) {
10708 std::rethrow_exception(std::current_exception());
10709 }
10710 catch( std::exception& ex ) {
10711 return ex.what();
10712 }
10713 catch( std::string& msg ) {
10714 return msg;
10715 }
10716 catch( const char* msg ) {
10717 return msg;
10718 }
10719 catch(...) {
10720 return "Unknown exception";
10721 }
10722 }
10723
10724 std::string ExceptionTranslatorRegistry::tryTranslators() const {
10725 if (m_translators.empty()) {
10726 std::rethrow_exception(std::current_exception());
10727 } else {
10728 return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
10729 }
10730 }
10731
10732 #else // ^^ Exceptions are enabled // Exceptions are disabled vv
10733 std::string ExceptionTranslatorRegistry::translateActiveException() const {
10734 CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
10735 }
10736
10737 std::string ExceptionTranslatorRegistry::tryTranslators() const {
10738 CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
10739 }
10740 #endif
10741
10742 }
10743 // end catch_exception_translator_registry.cpp
10744 // start catch_fatal_condition.cpp
10745
10746 #include <algorithm>
10747
10748 #if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
10749
10750 namespace Catch {
10751
10752 // If neither SEH nor signal handling is required, the handler impls
10753 // do not have to do anything, and can be empty.
10754 void FatalConditionHandler::engage_platform() {}
10755 void FatalConditionHandler::disengage_platform() {}
10756 FatalConditionHandler::FatalConditionHandler() = default;
10757 FatalConditionHandler::~FatalConditionHandler() = default;
10758
10759 } // end namespace Catch
10760
10761 #endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
10762
10763 #if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
10764 #error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
10765 #endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
10766
10767 #if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
10768
10769 namespace {
10770 //! Signals fatal error message to the run context
10771 void reportFatal( char const * const message ) {
10772 Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
10773 }
10774
10775 //! Minimal size Catch2 needs for its own fatal error handling.
10776 //! Picked anecdotally, so it might not be sufficient on all
10777 //! platforms, and for all configurations.
10778 constexpr std::size_t minStackSizeForErrors = 32 * 1024;
10779 } // end unnamed namespace
10780
10781 #endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
10782
10783 #if defined( CATCH_CONFIG_WINDOWS_SEH )
10784
10785 namespace Catch {
10786
10787 struct SignalDefs { DWORD id; const char* name; };
10788
10789 // There is no 1-1 mapping between signals and windows exceptions.
10790 // Windows can easily distinguish between SO and SigSegV,
10791 // but SigInt, SigTerm, etc are handled differently.
10792 static SignalDefs signalDefs[] = {
10793 { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION), "SIGILL - Illegal instruction signal" },
10794 { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
10795 { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
10796 { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
10797 };
10798
10799 static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
10800 for (auto const& def : signalDefs) {
10801 if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
10802 reportFatal(def.name);
10803 }
10804 }
10805 // If its not an exception we care about, pass it along.
10806 // This stops us from eating debugger breaks etc.
10807 return EXCEPTION_CONTINUE_SEARCH;
10808 }
10809
10810 // Since we do not support multiple instantiations, we put these
10811 // into global variables and rely on cleaning them up in outlined
10812 // constructors/destructors
10813 static PVOID exceptionHandlerHandle = nullptr;
10814
10815 // For MSVC, we reserve part of the stack memory for handling
10816 // memory overflow structured exception.
10817 FatalConditionHandler::FatalConditionHandler() {
10818 ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
10819 if (!SetThreadStackGuarantee(&guaranteeSize)) {
10820 // We do not want to fully error out, because needing
10821 // the stack reserve should be rare enough anyway.
10822 Catch::cerr()
10823 << "Failed to reserve piece of stack."
10824 << " Stack overflows will not be reported successfully.";
10825 }
10826 }
10827
10828 // We do not attempt to unset the stack guarantee, because
10829 // Windows does not support lowering the stack size guarantee.
10830 FatalConditionHandler::~FatalConditionHandler() = default;
10831
10832 void FatalConditionHandler::engage_platform() {
10833 // Register as first handler in current chain
10834 exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
10835 if (!exceptionHandlerHandle) {
10836 CATCH_RUNTIME_ERROR("Could not register vectored exception handler");
10837 }
10838 }
10839
10840 void FatalConditionHandler::disengage_platform() {
10841 if (!RemoveVectoredExceptionHandler(exceptionHandlerHandle)) {
10842 CATCH_RUNTIME_ERROR("Could not unregister vectored exception handler");
10843 }
10844 exceptionHandlerHandle = nullptr;
10845 }
10846
10847 } // end namespace Catch
10848
10849 #endif // CATCH_CONFIG_WINDOWS_SEH
10850
10851 #if defined( CATCH_CONFIG_POSIX_SIGNALS )
10852
10853 #include <signal.h>
10854
10855 namespace Catch {
10856
10857 struct SignalDefs {
10858 int id;
10859 const char* name;
10860 };
10861
10862 static SignalDefs signalDefs[] = {
10863 { SIGINT, "SIGINT - Terminal interrupt signal" },
10864 { SIGILL, "SIGILL - Illegal instruction signal" },
10865 { SIGFPE, "SIGFPE - Floating point error signal" },
10866 { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
10867 { SIGTERM, "SIGTERM - Termination request signal" },
10868 { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
10869 };
10870
10871 // Older GCCs trigger -Wmissing-field-initializers for T foo = {}
10872 // which is zero initialization, but not explicit. We want to avoid
10873 // that.
10874 #if defined(__GNUC__)
10875 # pragma GCC diagnostic push
10876 # pragma GCC diagnostic ignored "-Wmissing-field-initializers"
10877 #endif
10878
10879 static char* altStackMem = nullptr;
10880 static std::size_t altStackSize = 0;
10881 static stack_t oldSigStack{};
10882 static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
10883
10884 static void restorePreviousSignalHandlers() {
10885 // We set signal handlers back to the previous ones. Hopefully
10886 // nobody overwrote them in the meantime, and doesn't expect
10887 // their signal handlers to live past ours given that they
10888 // installed them after ours..
10889 for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
10890 sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
10891 }
10892 // Return the old stack
10893 sigaltstack(&oldSigStack, nullptr);
10894 }
10895
10896 static void handleSignal( int sig ) {
10897 char const * name = "<unknown signal>";
10898 for (auto const& def : signalDefs) {
10899 if (sig == def.id) {
10900 name = def.name;
10901 break;
10902 }
10903 }
10904 // We need to restore previous signal handlers and let them do
10905 // their thing, so that the users can have the debugger break
10906 // when a signal is raised, and so on.
10907 restorePreviousSignalHandlers();
10908 reportFatal( name );
10909 raise( sig );
10910 }
10911
10912 FatalConditionHandler::FatalConditionHandler() {
10913 assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
10914 if (altStackSize == 0) {
10915 altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
10916 }
10917 altStackMem = new char[altStackSize]();
10918 }
10919
10920 FatalConditionHandler::~FatalConditionHandler() {
10921 delete[] altStackMem;
10922 // We signal that another instance can be constructed by zeroing
10923 // out the pointer.
10924 altStackMem = nullptr;
10925 }
10926
10927 void FatalConditionHandler::engage_platform() {
10928 stack_t sigStack;
10929 sigStack.ss_sp = altStackMem;
10930 sigStack.ss_size = altStackSize;
10931 sigStack.ss_flags = 0;
10932 sigaltstack(&sigStack, &oldSigStack);
10933 struct sigaction sa = { };
10934
10935 sa.sa_handler = handleSignal;
10936 sa.sa_flags = SA_ONSTACK;
10937 for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
10938 sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
10939 }
10940 }
10941
10942 #if defined(__GNUC__)
10943 # pragma GCC diagnostic pop
10944 #endif
10945
10946 void FatalConditionHandler::disengage_platform() {
10947 restorePreviousSignalHandlers();
10948 }
10949
10950 } // end namespace Catch
10951
10952 #endif // CATCH_CONFIG_POSIX_SIGNALS
10953 // end catch_fatal_condition.cpp
10954 // start catch_generators.cpp
10955
10956 #include <limits>
10957 #include <set>
10958
10959 namespace Catch {
10960
10961 IGeneratorTracker::~IGeneratorTracker() {}
10962
10963 const char* GeneratorException::what() const noexcept {
10964 return m_msg;
10965 }
10966
10967 namespace Generators {
10968
10969 GeneratorUntypedBase::~GeneratorUntypedBase() {}
10970
10971 auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
10972 return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
10973 }
10974
10975 } // namespace Generators
10976 } // namespace Catch
10977 // end catch_generators.cpp
10978 // start catch_interfaces_capture.cpp
10979
10980 namespace Catch {
10981 IResultCapture::~IResultCapture() = default;
10982 }
10983 // end catch_interfaces_capture.cpp
10984 // start catch_interfaces_config.cpp
10985
10986 namespace Catch {
10987 IConfig::~IConfig() = default;
10988 }
10989 // end catch_interfaces_config.cpp
10990 // start catch_interfaces_exception.cpp
10991
10992 namespace Catch {
10993 IExceptionTranslator::~IExceptionTranslator() = default;
10994 IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
10995 }
10996 // end catch_interfaces_exception.cpp
10997 // start catch_interfaces_registry_hub.cpp
10998
10999 namespace Catch {
11000 IRegistryHub::~IRegistryHub() = default;
11001 IMutableRegistryHub::~IMutableRegistryHub() = default;
11002 }
11003 // end catch_interfaces_registry_hub.cpp
11004 // start catch_interfaces_reporter.cpp
11005
11006 // start catch_reporter_listening.h
11007
11008 namespace Catch {
11009
11010 class ListeningReporter : public IStreamingReporter {
11011 using Reporters = std::vector<IStreamingReporterPtr>;
11012 Reporters m_listeners;
11013 IStreamingReporterPtr m_reporter = nullptr;
11014 ReporterPreferences m_preferences;
11015
11016 public:
11017 ListeningReporter();
11018
11019 void addListener( IStreamingReporterPtr&& listener );
11020 void addReporter( IStreamingReporterPtr&& reporter );
11021
11022 public: // IStreamingReporter
11023
11024 ReporterPreferences getPreferences() const override;
11025
11026 void noMatchingTestCases( std::string const& spec ) override;
11027
11028 void reportInvalidArguments(std::string const&arg) override;
11029
11030 static std::set<Verbosity> getSupportedVerbosities();
11031
11032 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
11033 void benchmarkPreparing(std::string const& name) override;
11034 void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
11035 void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
11036 void benchmarkFailed(std::string const&) override;
11037 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
11038
11039 void testRunStarting( TestRunInfo const& testRunInfo ) override;
11040 void testGroupStarting( GroupInfo const& groupInfo ) override;
11041 void testCaseStarting( TestCaseInfo const& testInfo ) override;
11042 void sectionStarting( SectionInfo const& sectionInfo ) override;
11043 void assertionStarting( AssertionInfo const& assertionInfo ) override;
11044
11045 // The return value indicates if the messages buffer should be cleared:
11046 bool assertionEnded( AssertionStats const& assertionStats ) override;
11047 void sectionEnded( SectionStats const& sectionStats ) override;
11048 void testCaseEnded( TestCaseStats const& testCaseStats ) override;
11049 void testGroupEnded( TestGroupStats const& testGroupStats ) override;
11050 void testRunEnded( TestRunStats const& testRunStats ) override;
11051
11052 void skipTest( TestCaseInfo const& testInfo ) override;
11053 bool isMulti() const override;
11054
11055 };
11056
11057 } // end namespace Catch
11058
11059 // end catch_reporter_listening.h
11060 namespace Catch {
11061
11062 ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
11063 : m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
11064
11065 ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
11066 : m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
11067
11068 std::ostream& ReporterConfig::stream() const { return *m_stream; }
11069 IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
11070
11071 TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
11072
11073 GroupInfo::GroupInfo( std::string const& _name,
11074 std::size_t _groupIndex,
11075 std::size_t _groupsCount )
11076 : name( _name ),
11077 groupIndex( _groupIndex ),
11078 groupsCounts( _groupsCount )
11079 {}
11080
11081 AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
11082 std::vector<MessageInfo> const& _infoMessages,
11083 Totals const& _totals )
11084 : assertionResult( _assertionResult ),
11085 infoMessages( _infoMessages ),
11086 totals( _totals )
11087 {
11088 assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
11089
11090 if( assertionResult.hasMessage() ) {
11091 // Copy message into messages list.
11092 // !TBD This should have been done earlier, somewhere
11093 MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
11094 builder << assertionResult.getMessage();
11095 builder.m_info.message = builder.m_stream.str();
11096
11097 infoMessages.push_back( builder.m_info );
11098 }
11099 }
11100
11101 AssertionStats::~AssertionStats() = default;
11102
11103 SectionStats::SectionStats( SectionInfo const& _sectionInfo,
11104 Counts const& _assertions,
11105 double _durationInSeconds,
11106 bool _missingAssertions )
11107 : sectionInfo( _sectionInfo ),
11108 assertions( _assertions ),
11109 durationInSeconds( _durationInSeconds ),
11110 missingAssertions( _missingAssertions )
11111 {}
11112
11113 SectionStats::~SectionStats() = default;
11114
11115 TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
11116 Totals const& _totals,
11117 std::string const& _stdOut,
11118 std::string const& _stdErr,
11119 bool _aborting )
11120 : testInfo( _testInfo ),
11121 totals( _totals ),
11122 stdOut( _stdOut ),
11123 stdErr( _stdErr ),
11124 aborting( _aborting )
11125 {}
11126
11127 TestCaseStats::~TestCaseStats() = default;
11128
11129 TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
11130 Totals const& _totals,
11131 bool _aborting )
11132 : groupInfo( _groupInfo ),
11133 totals( _totals ),
11134 aborting( _aborting )
11135 {}
11136
11137 TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
11138 : groupInfo( _groupInfo ),
11139 aborting( false )
11140 {}
11141
11142 TestGroupStats::~TestGroupStats() = default;
11143
11144 TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
11145 Totals const& _totals,
11146 bool _aborting )
11147 : runInfo( _runInfo ),
11148 totals( _totals ),
11149 aborting( _aborting )
11150 {}
11151
11152 TestRunStats::~TestRunStats() = default;
11153
11154 void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
11155 bool IStreamingReporter::isMulti() const { return false; }
11156
11157 IReporterFactory::~IReporterFactory() = default;
11158 IReporterRegistry::~IReporterRegistry() = default;
11159
11160 } // end namespace Catch
11161 // end catch_interfaces_reporter.cpp
11162 // start catch_interfaces_runner.cpp
11163
11164 namespace Catch {
11165 IRunner::~IRunner() = default;
11166 }
11167 // end catch_interfaces_runner.cpp
11168 // start catch_interfaces_testcase.cpp
11169
11170 namespace Catch {
11171 ITestInvoker::~ITestInvoker() = default;
11172 ITestCaseRegistry::~ITestCaseRegistry() = default;
11173 }
11174 // end catch_interfaces_testcase.cpp
11175 // start catch_leak_detector.cpp
11176
11177 #ifdef CATCH_CONFIG_WINDOWS_CRTDBG
11178 #include <crtdbg.h>
11179
11180 namespace Catch {
11181
11182 LeakDetector::LeakDetector() {
11183 int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
11184 flag |= _CRTDBG_LEAK_CHECK_DF;
11185 flag |= _CRTDBG_ALLOC_MEM_DF;
11186 _CrtSetDbgFlag(flag);
11187 _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
11188 _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
11189 // Change this to leaking allocation's number to break there
11190 _CrtSetBreakAlloc(-1);
11191 }
11192 }
11193
11194 #else
11195
11196 Catch::LeakDetector::LeakDetector() {}
11197
11198 #endif
11199
11200 Catch::LeakDetector::~LeakDetector() {
11201 Catch::cleanUp();
11202 }
11203 // end catch_leak_detector.cpp
11204 // start catch_list.cpp
11205
11206 // start catch_list.h
11207
11208 #include <set>
11209
11210 namespace Catch {
11211
11212 std::size_t listTests( Config const& config );
11213
11214 std::size_t listTestsNamesOnly( Config const& config );
11215
11216 struct TagInfo {
11217 void add( std::string const& spelling );
11218 std::string all() const;
11219
11220 std::set<std::string> spellings;
11221 std::size_t count = 0;
11222 };
11223
11224 std::size_t listTags( Config const& config );
11225
11226 std::size_t listReporters();
11227
11228 Option<std::size_t> list( std::shared_ptr<Config> const& config );
11229
11230 } // end namespace Catch
11231
11232 // end catch_list.h
11233 // start catch_text.h
11234
11235 namespace Catch {
11236 using namespace clara::TextFlow;
11237 }
11238
11239 // end catch_text.h
11240 #include <limits>
11241 #include <algorithm>
11242 #include <iomanip>
11243
11244 namespace Catch {
11245
11246 std::size_t listTests( Config const& config ) {
11247 TestSpec const& testSpec = config.testSpec();
11248 if( config.hasTestFilters() )
11249 Catch::cout() << "Matching test cases:\n";
11250 else {
11251 Catch::cout() << "All available test cases:\n";
11252 }
11253
11254 auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
11255 for( auto const& testCaseInfo : matchedTestCases ) {
11256 Colour::Code colour = testCaseInfo.isHidden()
11257 ? Colour::SecondaryText
11258 : Colour::None;
11259 Colour colourGuard( colour );
11260
11261 Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
11262 if( config.verbosity() >= Verbosity::High ) {
11263 Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
11264 std::string description = testCaseInfo.description;
11265 if( description.empty() )
11266 description = "(NO DESCRIPTION)";
11267 Catch::cout() << Column( description ).indent(4) << std::endl;
11268 }
11269 if( !testCaseInfo.tags.empty() )
11270 Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
11271 }
11272
11273 if( !config.hasTestFilters() )
11274 Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
11275 else
11276 Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
11277 return matchedTestCases.size();
11278 }
11279
11280 std::size_t listTestsNamesOnly( Config const& config ) {
11281 TestSpec const& testSpec = config.testSpec();
11282 std::size_t matchedTests = 0;
11283 std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
11284 for( auto const& testCaseInfo : matchedTestCases ) {
11285 matchedTests++;
11286 if( startsWith( testCaseInfo.name, '#' ) )
11287 Catch::cout() << '"' << testCaseInfo.name << '"';
11288 else
11289 Catch::cout() << testCaseInfo.name;
11290 if ( config.verbosity() >= Verbosity::High )
11291 Catch::cout() << "\t@" << testCaseInfo.lineInfo;
11292 Catch::cout() << std::endl;
11293 }
11294 return matchedTests;
11295 }
11296
11297 void TagInfo::add( std::string const& spelling ) {
11298 ++count;
11299 spellings.insert( spelling );
11300 }
11301
11302 std::string TagInfo::all() const {
11303 size_t size = 0;
11304 for (auto const& spelling : spellings) {
11305 // Add 2 for the brackes
11306 size += spelling.size() + 2;
11307 }
11308
11309 std::string out; out.reserve(size);
11310 for (auto const& spelling : spellings) {
11311 out += '[';
11312 out += spelling;
11313 out += ']';
11314 }
11315 return out;
11316 }
11317
11318 std::size_t listTags( Config const& config ) {
11319 TestSpec const& testSpec = config.testSpec();
11320 if( config.hasTestFilters() )
11321 Catch::cout() << "Tags for matching test cases:\n";
11322 else {
11323 Catch::cout() << "All available tags:\n";
11324 }
11325
11326 std::map<std::string, TagInfo> tagCounts;
11327
11328 std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
11329 for( auto const& testCase : matchedTestCases ) {
11330 for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
11331 std::string lcaseTagName = toLower( tagName );
11332 auto countIt = tagCounts.find( lcaseTagName );
11333 if( countIt == tagCounts.end() )
11334 countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
11335 countIt->second.add( tagName );
11336 }
11337 }
11338
11339 for( auto const& tagCount : tagCounts ) {
11340 ReusableStringStream rss;
11341 rss << " " << std::setw(2) << tagCount.second.count << " ";
11342 auto str = rss.str();
11343 auto wrapper = Column( tagCount.second.all() )
11344 .initialIndent( 0 )
11345 .indent( str.size() )
11346 .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
11347 Catch::cout() << str << wrapper << '\n';
11348 }
11349 Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
11350 return tagCounts.size();
11351 }
11352
11353 std::size_t listReporters() {
11354 Catch::cout() << "Available reporters:\n";
11355 IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
11356 std::size_t maxNameLen = 0;
11357 for( auto const& factoryKvp : factories )
11358 maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
11359
11360 for( auto const& factoryKvp : factories ) {
11361 Catch::cout()
11362 << Column( factoryKvp.first + ":" )
11363 .indent(2)
11364 .width( 5+maxNameLen )
11365 + Column( factoryKvp.second->getDescription() )
11366 .initialIndent(0)
11367 .indent(2)
11368 .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
11369 << "\n";
11370 }
11371 Catch::cout() << std::endl;
11372 return factories.size();
11373 }
11374
11375 Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
11376 Option<std::size_t> listedCount;
11377 getCurrentMutableContext().setConfig( config );
11378 if( config->listTests() )
11379 listedCount = listedCount.valueOr(0) + listTests( *config );
11380 if( config->listTestNamesOnly() )
11381 listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
11382 if( config->listTags() )
11383 listedCount = listedCount.valueOr(0) + listTags( *config );
11384 if( config->listReporters() )
11385 listedCount = listedCount.valueOr(0) + listReporters();
11386 return listedCount;
11387 }
11388
11389 } // end namespace Catch
11390 // end catch_list.cpp
11391 // start catch_matchers.cpp
11392
11393 namespace Catch {
11394 namespace Matchers {
11395 namespace Impl {
11396
11397 std::string MatcherUntypedBase::toString() const {
11398 if( m_cachedToString.empty() )
11399 m_cachedToString = describe();
11400 return m_cachedToString;
11401 }
11402
11403 MatcherUntypedBase::~MatcherUntypedBase() = default;
11404
11405 } // namespace Impl
11406 } // namespace Matchers
11407
11408 using namespace Matchers;
11409 using Matchers::Impl::MatcherBase;
11410
11411 } // namespace Catch
11412 // end catch_matchers.cpp
11413 // start catch_matchers_exception.cpp
11414
11415 namespace Catch {
11416 namespace Matchers {
11417 namespace Exception {
11418
11419 bool ExceptionMessageMatcher::match(std::exception const& ex) const {
11420 return ex.what() == m_message;
11421 }
11422
11423 std::string ExceptionMessageMatcher::describe() const {
11424 return "exception message matches \"" + m_message + "\"";
11425 }
11426
11427 }
11428 Exception::ExceptionMessageMatcher Message(std::string const& message) {
11429 return Exception::ExceptionMessageMatcher(message);
11430 }
11431
11432 // namespace Exception
11433 } // namespace Matchers
11434 } // namespace Catch
11435 // end catch_matchers_exception.cpp
11436 // start catch_matchers_floating.cpp
11437
11438 // start catch_polyfills.hpp
11439
11440 namespace Catch {
11441 bool isnan(float f);
11442 bool isnan(double d);
11443 }
11444
11445 // end catch_polyfills.hpp
11446 // start catch_to_string.hpp
11447
11448 #include <string>
11449
11450 namespace Catch {
11451 template <typename T>
11452 std::string to_string(T const& t) {
11453 #if defined(CATCH_CONFIG_CPP11_TO_STRING)
11454 return std::to_string(t);
11455 #else
11456 ReusableStringStream rss;
11457 rss << t;
11458 return rss.str();
11459 #endif
11460 }
11461 } // end namespace Catch
11462
11463 // end catch_to_string.hpp
11464 #include <algorithm>
11465 #include <cmath>
11466 #include <cstdlib>
11467 #include <cstdint>
11468 #include <cstring>
11469 #include <sstream>
11470 #include <type_traits>
11471 #include <iomanip>
11472 #include <limits>
11473
11474 namespace Catch {
11475 namespace {
11476
11477 int32_t convert(float f) {
11478 static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
11479 int32_t i;
11480 std::memcpy(&i, &f, sizeof(f));
11481 return i;
11482 }
11483
11484 int64_t convert(double d) {
11485 static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
11486 int64_t i;
11487 std::memcpy(&i, &d, sizeof(d));
11488 return i;
11489 }
11490
11491 template <typename FP>
11492 bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
11493 // Comparison with NaN should always be false.
11494 // This way we can rule it out before getting into the ugly details
11495 if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
11496 return false;
11497 }
11498
11499 auto lc = convert(lhs);
11500 auto rc = convert(rhs);
11501
11502 if ((lc < 0) != (rc < 0)) {
11503 // Potentially we can have +0 and -0
11504 return lhs == rhs;
11505 }
11506
11507 // static cast as a workaround for IBM XLC
11508 auto ulpDiff = std::abs(static_cast<FP>(lc - rc));
11509 return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
11510 }
11511
11512 #if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
11513
11514 float nextafter(float x, float y) {
11515 return ::nextafterf(x, y);
11516 }
11517
11518 double nextafter(double x, double y) {
11519 return ::nextafter(x, y);
11520 }
11521
11522 #endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
11523
11524 template <typename FP>
11525 FP step(FP start, FP direction, uint64_t steps) {
11526 for (uint64_t i = 0; i < steps; ++i) {
11527 #if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
11528 start = Catch::nextafter(start, direction);
11529 #else
11530 start = std::nextafter(start, direction);
11531 #endif
11532 }
11533 return start;
11534 }
11535
11536 // Performs equivalent check of std::fabs(lhs - rhs) <= margin
11537 // But without the subtraction to allow for INFINITY in comparison
11538 bool marginComparison(double lhs, double rhs, double margin) {
11539 return (lhs + margin >= rhs) && (rhs + margin >= lhs);
11540 }
11541
11542 template <typename FloatingPoint>
11543 void write(std::ostream& out, FloatingPoint num) {
11544 out << std::scientific
11545 << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
11546 << num;
11547 }
11548
11549 } // end anonymous namespace
11550
11551 namespace Matchers {
11552 namespace Floating {
11553
11554 enum class FloatingPointKind : uint8_t {
11555 Float,
11556 Double
11557 };
11558
11559 WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
11560 :m_target{ target }, m_margin{ margin } {
11561 CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
11562 << " Margin has to be non-negative.");
11563 }
11564
11565 // Performs equivalent check of std::fabs(lhs - rhs) <= margin
11566 // But without the subtraction to allow for INFINITY in comparison
11567 bool WithinAbsMatcher::match(double const& matchee) const {
11568 return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
11569 }
11570
11571 std::string WithinAbsMatcher::describe() const {
11572 return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
11573 }
11574
11575 WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
11576 :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
11577 CATCH_ENFORCE(m_type == FloatingPointKind::Double
11578 || m_ulps < (std::numeric_limits<uint32_t>::max)(),
11579 "Provided ULP is impossibly large for a float comparison.");
11580 }
11581
11582 #if defined(__clang__)
11583 #pragma clang diagnostic push
11584 // Clang <3.5 reports on the default branch in the switch below
11585 #pragma clang diagnostic ignored "-Wunreachable-code"
11586 #endif
11587
11588 bool WithinUlpsMatcher::match(double const& matchee) const {
11589 switch (m_type) {
11590 case FloatingPointKind::Float:
11591 return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
11592 case FloatingPointKind::Double:
11593 return almostEqualUlps<double>(matchee, m_target, m_ulps);
11594 default:
11595 CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
11596 }
11597 }
11598
11599 #if defined(__clang__)
11600 #pragma clang diagnostic pop
11601 #endif
11602
11603 std::string WithinUlpsMatcher::describe() const {
11604 std::stringstream ret;
11605
11606 ret << "is within " << m_ulps << " ULPs of ";
11607
11608 if (m_type == FloatingPointKind::Float) {
11609 write(ret, static_cast<float>(m_target));
11610 ret << 'f';
11611 } else {
11612 write(ret, m_target);
11613 }
11614
11615 ret << " ([";
11616 if (m_type == FloatingPointKind::Double) {
11617 write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
11618 ret << ", ";
11619 write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
11620 } else {
11621 // We have to cast INFINITY to float because of MinGW, see #1782
11622 write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
11623 ret << ", ";
11624 write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
11625 }
11626 ret << "])";
11627
11628 return ret.str();
11629 }
11630
11631 WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
11632 m_target(target),
11633 m_epsilon(epsilon){
11634 CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense.");
11635 CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense.");
11636 }
11637
11638 bool WithinRelMatcher::match(double const& matchee) const {
11639 const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
11640 return marginComparison(matchee, m_target,
11641 std::isinf(relMargin)? 0 : relMargin);
11642 }
11643
11644 std::string WithinRelMatcher::describe() const {
11645 Catch::ReusableStringStream sstr;
11646 sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
11647 return sstr.str();
11648 }
11649
11650 }// namespace Floating
11651
11652 Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
11653 return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
11654 }
11655
11656 Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
11657 return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
11658 }
11659
11660 Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
11661 return Floating::WithinAbsMatcher(target, margin);
11662 }
11663
11664 Floating::WithinRelMatcher WithinRel(double target, double eps) {
11665 return Floating::WithinRelMatcher(target, eps);
11666 }
11667
11668 Floating::WithinRelMatcher WithinRel(double target) {
11669 return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
11670 }
11671
11672 Floating::WithinRelMatcher WithinRel(float target, float eps) {
11673 return Floating::WithinRelMatcher(target, eps);
11674 }
11675
11676 Floating::WithinRelMatcher WithinRel(float target) {
11677 return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
11678 }
11679
11680 } // namespace Matchers
11681 } // namespace Catch
11682 // end catch_matchers_floating.cpp
11683 // start catch_matchers_generic.cpp
11684
11685 std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
11686 if (desc.empty()) {
11687 return "matches undescribed predicate";
11688 } else {
11689 return "matches predicate: \"" + desc + '"';
11690 }
11691 }
11692 // end catch_matchers_generic.cpp
11693 // start catch_matchers_string.cpp
11694
11695 #include <regex>
11696
11697 namespace Catch {
11698 namespace Matchers {
11699
11700 namespace StdString {
11701
11702 CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
11703 : m_caseSensitivity( caseSensitivity ),
11704 m_str( adjustString( str ) )
11705 {}
11706 std::string CasedString::adjustString( std::string const& str ) const {
11707 return m_caseSensitivity == CaseSensitive::No
11708 ? toLower( str )
11709 : str;
11710 }
11711 std::string CasedString::caseSensitivitySuffix() const {
11712 return m_caseSensitivity == CaseSensitive::No
11713 ? " (case insensitive)"
11714 : std::string();
11715 }
11716
11717 StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator )
11718 : m_comparator( comparator ),
11719 m_operation( operation ) {
11720 }
11721
11722 std::string StringMatcherBase::describe() const {
11723 std::string description;
11724 description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
11725 m_comparator.caseSensitivitySuffix().size());
11726 description += m_operation;
11727 description += ": \"";
11728 description += m_comparator.m_str;
11729 description += "\"";
11730 description += m_comparator.caseSensitivitySuffix();
11731 return description;
11732 }
11733
11734 EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {}
11735
11736 bool EqualsMatcher::match( std::string const& source ) const {
11737 return m_comparator.adjustString( source ) == m_comparator.m_str;
11738 }
11739
11740 ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {}
11741
11742 bool ContainsMatcher::match( std::string const& source ) const {
11743 return contains( m_comparator.adjustString( source ), m_comparator.m_str );
11744 }
11745
11746 StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {}
11747
11748 bool StartsWithMatcher::match( std::string const& source ) const {
11749 return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
11750 }
11751
11752 EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {}
11753
11754 bool EndsWithMatcher::match( std::string const& source ) const {
11755 return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
11756 }
11757
11758 RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
11759
11760 bool RegexMatcher::match(std::string const& matchee) const {
11761 auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
11762 if (m_caseSensitivity == CaseSensitive::Choice::No) {
11763 flags |= std::regex::icase;
11764 }
11765 auto reg = std::regex(m_regex, flags);
11766 return std::regex_match(matchee, reg);
11767 }
11768
11769 std::string RegexMatcher::describe() const {
11770 return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
11771 }
11772
11773 } // namespace StdString
11774
11775 StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
11776 return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
11777 }
11778 StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
11779 return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) );
11780 }
11781 StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
11782 return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) );
11783 }
11784 StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
11785 return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
11786 }
11787
11788 StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
11789 return StdString::RegexMatcher(regex, caseSensitivity);
11790 }
11791
11792 } // namespace Matchers
11793 } // namespace Catch
11794 // end catch_matchers_string.cpp
11795 // start catch_message.cpp
11796
11797 // start catch_uncaught_exceptions.h
11798
11799 namespace Catch {
11800 bool uncaught_exceptions();
11801 } // end namespace Catch
11802
11803 // end catch_uncaught_exceptions.h
11804 #include <cassert>
11805 #include <stack>
11806
11807 namespace Catch {
11808
11809 MessageInfo::MessageInfo( StringRef const& _macroName,
11810 SourceLineInfo const& _lineInfo,
11811 ResultWas::OfType _type )
11812 : macroName( _macroName ),
11813 lineInfo( _lineInfo ),
11814 type( _type ),
11815 sequence( ++globalCount )
11816 {}
11817
11818 bool MessageInfo::operator==( MessageInfo const& other ) const {
11819 return sequence == other.sequence;
11820 }
11821
11822 bool MessageInfo::operator<( MessageInfo const& other ) const {
11823 return sequence < other.sequence;
11824 }
11825
11826 // This may need protecting if threading support is added
11827 unsigned int MessageInfo::globalCount = 0;
11828
11829 ////////////////////////////////////////////////////////////////////////////
11830
11831 Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
11832 SourceLineInfo const& lineInfo,
11833 ResultWas::OfType type )
11834 :m_info(macroName, lineInfo, type) {}
11835
11836 ////////////////////////////////////////////////////////////////////////////
11837
11838 ScopedMessage::ScopedMessage( MessageBuilder const& builder )
11839 : m_info( builder.m_info ), m_moved()
11840 {
11841 m_info.message = builder.m_stream.str();
11842 getResultCapture().pushScopedMessage( m_info );
11843 }
11844
11845 ScopedMessage::ScopedMessage( ScopedMessage&& old )
11846 : m_info( old.m_info ), m_moved()
11847 {
11848 old.m_moved = true;
11849 }
11850
11851 ScopedMessage::~ScopedMessage() {
11852 if ( !uncaught_exceptions() && !m_moved ){
11853 getResultCapture().popScopedMessage(m_info);
11854 }
11855 }
11856
11857 Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
11858 auto trimmed = [&] (size_t start, size_t end) {
11859 while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
11860 ++start;
11861 }
11862 while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
11863 --end;
11864 }
11865 return names.substr(start, end - start + 1);
11866 };
11867 auto skipq = [&] (size_t start, char quote) {
11868 for (auto i = start + 1; i < names.size() ; ++i) {
11869 if (names[i] == quote)
11870 return i;
11871 if (names[i] == '\\')
11872 ++i;
11873 }
11874 CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
11875 };
11876
11877 size_t start = 0;
11878 std::stack<char> openings;
11879 for (size_t pos = 0; pos < names.size(); ++pos) {
11880 char c = names[pos];
11881 switch (c) {
11882 case '[':
11883 case '{':
11884 case '(':
11885 // It is basically impossible to disambiguate between
11886 // comparison and start of template args in this context
11887 // case '<':
11888 openings.push(c);
11889 break;
11890 case ']':
11891 case '}':
11892 case ')':
11893 // case '>':
11894 openings.pop();
11895 break;
11896 case '"':
11897 case '\'':
11898 pos = skipq(pos, c);
11899 break;
11900 case ',':
11901 if (start != pos && openings.empty()) {
11902 m_messages.emplace_back(macroName, lineInfo, resultType);
11903 m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
11904 m_messages.back().message += " := ";
11905 start = pos;
11906 }
11907 }
11908 }
11909 assert(openings.empty() && "Mismatched openings");
11910 m_messages.emplace_back(macroName, lineInfo, resultType);
11911 m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
11912 m_messages.back().message += " := ";
11913 }
11914 Capturer::~Capturer() {
11915 if ( !uncaught_exceptions() ){
11916 assert( m_captured == m_messages.size() );
11917 for( size_t i = 0; i < m_captured; ++i )
11918 m_resultCapture.popScopedMessage( m_messages[i] );
11919 }
11920 }
11921
11922 void Capturer::captureValue( size_t index, std::string const& value ) {
11923 assert( index < m_messages.size() );
11924 m_messages[index].message += value;
11925 m_resultCapture.pushScopedMessage( m_messages[index] );
11926 m_captured++;
11927 }
11928
11929 } // end namespace Catch
11930 // end catch_message.cpp
11931 // start catch_output_redirect.cpp
11932
11933 // start catch_output_redirect.h
11934 #ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
11935 #define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
11936
11937 #include <cstdio>
11938 #include <iosfwd>
11939 #include <string>
11940
11941 namespace Catch {
11942
11943 class RedirectedStream {
11944 std::ostream& m_originalStream;
11945 std::ostream& m_redirectionStream;
11946 std::streambuf* m_prevBuf;
11947
11948 public:
11949 RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
11950 ~RedirectedStream();
11951 };
11952
11953 class RedirectedStdOut {
11954 ReusableStringStream m_rss;
11955 RedirectedStream m_cout;
11956 public:
11957 RedirectedStdOut();
11958 auto str() const -> std::string;
11959 };
11960
11961 // StdErr has two constituent streams in C++, std::cerr and std::clog
11962 // This means that we need to redirect 2 streams into 1 to keep proper
11963 // order of writes
11964 class RedirectedStdErr {
11965 ReusableStringStream m_rss;
11966 RedirectedStream m_cerr;
11967 RedirectedStream m_clog;
11968 public:
11969 RedirectedStdErr();
11970 auto str() const -> std::string;
11971 };
11972
11973 class RedirectedStreams {
11974 public:
11975 RedirectedStreams(RedirectedStreams const&) = delete;
11976 RedirectedStreams& operator=(RedirectedStreams const&) = delete;
11977 RedirectedStreams(RedirectedStreams&&) = delete;
11978 RedirectedStreams& operator=(RedirectedStreams&&) = delete;
11979
11980 RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
11981 ~RedirectedStreams();
11982 private:
11983 std::string& m_redirectedCout;
11984 std::string& m_redirectedCerr;
11985 RedirectedStdOut m_redirectedStdOut;
11986 RedirectedStdErr m_redirectedStdErr;
11987 };
11988
11989 #if defined(CATCH_CONFIG_NEW_CAPTURE)
11990
11991 // Windows's implementation of std::tmpfile is terrible (it tries
11992 // to create a file inside system folder, thus requiring elevated
11993 // privileges for the binary), so we have to use tmpnam(_s) and
11994 // create the file ourselves there.
11995 class TempFile {
11996 public:
11997 TempFile(TempFile const&) = delete;
11998 TempFile& operator=(TempFile const&) = delete;
11999 TempFile(TempFile&&) = delete;
12000 TempFile& operator=(TempFile&&) = delete;
12001
12002 TempFile();
12003 ~TempFile();
12004
12005 std::FILE* getFile();
12006 std::string getContents();
12007
12008 private:
12009 std::FILE* m_file = nullptr;
12010 #if defined(_MSC_VER)
12011 char m_buffer[L_tmpnam] = { 0 };
12012 #endif
12013 };
12014
12015 class OutputRedirect {
12016 public:
12017 OutputRedirect(OutputRedirect const&) = delete;
12018 OutputRedirect& operator=(OutputRedirect const&) = delete;
12019 OutputRedirect(OutputRedirect&&) = delete;
12020 OutputRedirect& operator=(OutputRedirect&&) = delete;
12021
12022 OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
12023 ~OutputRedirect();
12024
12025 private:
12026 int m_originalStdout = -1;
12027 int m_originalStderr = -1;
12028 TempFile m_stdoutFile;
12029 TempFile m_stderrFile;
12030 std::string& m_stdoutDest;
12031 std::string& m_stderrDest;
12032 };
12033
12034 #endif
12035
12036 } // end namespace Catch
12037
12038 #endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
12039 // end catch_output_redirect.h
12040 #include <cstdio>
12041 #include <cstring>
12042 #include <fstream>
12043 #include <sstream>
12044 #include <stdexcept>
12045
12046 #if defined(CATCH_CONFIG_NEW_CAPTURE)
12047 #if defined(_MSC_VER)
12048 #include <io.h> //_dup and _dup2
12049 #define dup _dup
12050 #define dup2 _dup2
12051 #define fileno _fileno
12052 #else
12053 #include <unistd.h> // dup and dup2
12054 #endif
12055 #endif
12056
12057 namespace Catch {
12058
12059 RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
12060 : m_originalStream( originalStream ),
12061 m_redirectionStream( redirectionStream ),
12062 m_prevBuf( m_originalStream.rdbuf() )
12063 {
12064 m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
12065 }
12066
12067 RedirectedStream::~RedirectedStream() {
12068 m_originalStream.rdbuf( m_prevBuf );
12069 }
12070
12071 RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
12072 auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
12073
12074 RedirectedStdErr::RedirectedStdErr()
12075 : m_cerr( Catch::cerr(), m_rss.get() ),
12076 m_clog( Catch::clog(), m_rss.get() )
12077 {}
12078 auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
12079
12080 RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
12081 : m_redirectedCout(redirectedCout),
12082 m_redirectedCerr(redirectedCerr)
12083 {}
12084
12085 RedirectedStreams::~RedirectedStreams() {
12086 m_redirectedCout += m_redirectedStdOut.str();
12087 m_redirectedCerr += m_redirectedStdErr.str();
12088 }
12089
12090 #if defined(CATCH_CONFIG_NEW_CAPTURE)
12091
12092 #if defined(_MSC_VER)
12093 TempFile::TempFile() {
12094 if (tmpnam_s(m_buffer)) {
12095 CATCH_RUNTIME_ERROR("Could not get a temp filename");
12096 }
12097 if (fopen_s(&m_file, m_buffer, "w+")) {
12098 char buffer[100];
12099 if (strerror_s(buffer, errno)) {
12100 CATCH_RUNTIME_ERROR("Could not translate errno to a string");
12101 }
12102 CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
12103 }
12104 }
12105 #else
12106 TempFile::TempFile() {
12107 m_file = std::tmpfile();
12108 if (!m_file) {
12109 CATCH_RUNTIME_ERROR("Could not create a temp file.");
12110 }
12111 }
12112
12113 #endif
12114
12115 TempFile::~TempFile() {
12116 // TBD: What to do about errors here?
12117 std::fclose(m_file);
12118 // We manually create the file on Windows only, on Linux
12119 // it will be autodeleted
12120 #if defined(_MSC_VER)
12121 std::remove(m_buffer);
12122 #endif
12123 }
12124
12125 FILE* TempFile::getFile() {
12126 return m_file;
12127 }
12128
12129 std::string TempFile::getContents() {
12130 std::stringstream sstr;
12131 char buffer[100] = {};
12132 std::rewind(m_file);
12133 while (std::fgets(buffer, sizeof(buffer), m_file)) {
12134 sstr << buffer;
12135 }
12136 return sstr.str();
12137 }
12138
12139 OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
12140 m_originalStdout(dup(1)),
12141 m_originalStderr(dup(2)),
12142 m_stdoutDest(stdout_dest),
12143 m_stderrDest(stderr_dest) {
12144 dup2(fileno(m_stdoutFile.getFile()), 1);
12145 dup2(fileno(m_stderrFile.getFile()), 2);
12146 }
12147
12148 OutputRedirect::~OutputRedirect() {
12149 Catch::cout() << std::flush;
12150 fflush(stdout);
12151 // Since we support overriding these streams, we flush cerr
12152 // even though std::cerr is unbuffered
12153 Catch::cerr() << std::flush;
12154 Catch::clog() << std::flush;
12155 fflush(stderr);
12156
12157 dup2(m_originalStdout, 1);
12158 dup2(m_originalStderr, 2);
12159
12160 m_stdoutDest += m_stdoutFile.getContents();
12161 m_stderrDest += m_stderrFile.getContents();
12162 }
12163
12164 #endif // CATCH_CONFIG_NEW_CAPTURE
12165
12166 } // namespace Catch
12167
12168 #if defined(CATCH_CONFIG_NEW_CAPTURE)
12169 #if defined(_MSC_VER)
12170 #undef dup
12171 #undef dup2
12172 #undef fileno
12173 #endif
12174 #endif
12175 // end catch_output_redirect.cpp
12176 // start catch_polyfills.cpp
12177
12178 #include <cmath>
12179
12180 namespace Catch {
12181
12182 #if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
12183 bool isnan(float f) {
12184 return std::isnan(f);
12185 }
12186 bool isnan(double d) {
12187 return std::isnan(d);
12188 }
12189 #else
12190 // For now we only use this for embarcadero
12191 bool isnan(float f) {
12192 return std::_isnan(f);
12193 }
12194 bool isnan(double d) {
12195 return std::_isnan(d);
12196 }
12197 #endif
12198
12199 } // end namespace Catch
12200 // end catch_polyfills.cpp
12201 // start catch_random_number_generator.cpp
12202
12203 namespace Catch {
12204
12205 namespace {
12206
12207 #if defined(_MSC_VER)
12208 #pragma warning(push)
12209 #pragma warning(disable:4146) // we negate uint32 during the rotate
12210 #endif
12211 // Safe rotr implementation thanks to John Regehr
12212 uint32_t rotate_right(uint32_t val, uint32_t count) {
12213 const uint32_t mask = 31;
12214 count &= mask;
12215 return (val >> count) | (val << (-count & mask));
12216 }
12217
12218 #if defined(_MSC_VER)
12219 #pragma warning(pop)
12220 #endif
12221
12222 }
12223
12224 SimplePcg32::SimplePcg32(result_type seed_) {
12225 seed(seed_);
12226 }
12227
12228 void SimplePcg32::seed(result_type seed_) {
12229 m_state = 0;
12230 (*this)();
12231 m_state += seed_;
12232 (*this)();
12233 }
12234
12235 void SimplePcg32::discard(uint64_t skip) {
12236 // We could implement this to run in O(log n) steps, but this
12237 // should suffice for our use case.
12238 for (uint64_t s = 0; s < skip; ++s) {
12239 static_cast<void>((*this)());
12240 }
12241 }
12242
12243 SimplePcg32::result_type SimplePcg32::operator()() {
12244 // prepare the output value
12245 const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
12246 const auto output = rotate_right(xorshifted, m_state >> 59u);
12247
12248 // advance state
12249 m_state = m_state * 6364136223846793005ULL + s_inc;
12250
12251 return output;
12252 }
12253
12254 bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
12255 return lhs.m_state == rhs.m_state;
12256 }
12257
12258 bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
12259 return lhs.m_state != rhs.m_state;
12260 }
12261 }
12262 // end catch_random_number_generator.cpp
12263 // start catch_registry_hub.cpp
12264
12265 // start catch_test_case_registry_impl.h
12266
12267 #include <vector>
12268 #include <set>
12269 #include <algorithm>
12270 #include <ios>
12271
12272 namespace Catch {
12273
12274 class TestCase;
12275 struct IConfig;
12276
12277 std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
12278
12279 bool isThrowSafe( TestCase const& testCase, IConfig const& config );
12280 bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
12281
12282 void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
12283
12284 std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
12285 std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
12286
12287 class TestRegistry : public ITestCaseRegistry {
12288 public:
12289 virtual ~TestRegistry() = default;
12290
12291 virtual void registerTest( TestCase const& testCase );
12292
12293 std::vector<TestCase> const& getAllTests() const override;
12294 std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
12295
12296 private:
12297 std::vector<TestCase> m_functions;
12298 mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
12299 mutable std::vector<TestCase> m_sortedFunctions;
12300 std::size_t m_unnamedCount = 0;
12301 std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
12302 };
12303
12304 ///////////////////////////////////////////////////////////////////////////
12305
12306 class TestInvokerAsFunction : public ITestInvoker {
12307 void(*m_testAsFunction)();
12308 public:
12309 TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
12310
12311 void invoke() const override;
12312 };
12313
12314 std::string extractClassName( StringRef const& classOrQualifiedMethodName );
12315
12316 ///////////////////////////////////////////////////////////////////////////
12317
12318 } // end namespace Catch
12319
12320 // end catch_test_case_registry_impl.h
12321 // start catch_reporter_registry.h
12322
12323 #include <map>
12324
12325 namespace Catch {
12326
12327 class ReporterRegistry : public IReporterRegistry {
12328
12329 public:
12330
12331 ~ReporterRegistry() override;
12332
12333 IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
12334
12335 void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
12336 void registerListener( IReporterFactoryPtr const& factory );
12337
12338 FactoryMap const& getFactories() const override;
12339 Listeners const& getListeners() const override;
12340
12341 private:
12342 FactoryMap m_factories;
12343 Listeners m_listeners;
12344 };
12345 }
12346
12347 // end catch_reporter_registry.h
12348 // start catch_tag_alias_registry.h
12349
12350 // start catch_tag_alias.h
12351
12352 #include <string>
12353
12354 namespace Catch {
12355
12356 struct TagAlias {
12357 TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
12358
12359 std::string tag;
12360 SourceLineInfo lineInfo;
12361 };
12362
12363 } // end namespace Catch
12364
12365 // end catch_tag_alias.h
12366 #include <map>
12367
12368 namespace Catch {
12369
12370 class TagAliasRegistry : public ITagAliasRegistry {
12371 public:
12372 ~TagAliasRegistry() override;
12373 TagAlias const* find( std::string const& alias ) const override;
12374 std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
12375 void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
12376
12377 private:
12378 std::map<std::string, TagAlias> m_registry;
12379 };
12380
12381 } // end namespace Catch
12382
12383 // end catch_tag_alias_registry.h
12384 // start catch_startup_exception_registry.h
12385
12386 #include <vector>
12387 #include <exception>
12388
12389 namespace Catch {
12390
12391 class StartupExceptionRegistry {
12392 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
12393 public:
12394 void add(std::exception_ptr const& exception) noexcept;
12395 std::vector<std::exception_ptr> const& getExceptions() const noexcept;
12396 private:
12397 std::vector<std::exception_ptr> m_exceptions;
12398 #endif
12399 };
12400
12401 } // end namespace Catch
12402
12403 // end catch_startup_exception_registry.h
12404 // start catch_singletons.hpp
12405
12406 namespace Catch {
12407
12408 struct ISingleton {
12409 virtual ~ISingleton();
12410 };
12411
12412 void addSingleton( ISingleton* singleton );
12413 void cleanupSingletons();
12414
12415 template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
12416 class Singleton : SingletonImplT, public ISingleton {
12417
12418 static auto getInternal() -> Singleton* {
12419 static Singleton* s_instance = nullptr;
12420 if( !s_instance ) {
12421 s_instance = new Singleton;
12422 addSingleton( s_instance );
12423 }
12424 return s_instance;
12425 }
12426
12427 public:
12428 static auto get() -> InterfaceT const& {
12429 return *getInternal();
12430 }
12431 static auto getMutable() -> MutableInterfaceT& {
12432 return *getInternal();
12433 }
12434 };
12435
12436 } // namespace Catch
12437
12438 // end catch_singletons.hpp
12439 namespace Catch {
12440
12441 namespace {
12442
12443 class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
12444 private NonCopyable {
12445
12446 public: // IRegistryHub
12447 RegistryHub() = default;
12448 IReporterRegistry const& getReporterRegistry() const override {
12449 return m_reporterRegistry;
12450 }
12451 ITestCaseRegistry const& getTestCaseRegistry() const override {
12452 return m_testCaseRegistry;
12453 }
12454 IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
12455 return m_exceptionTranslatorRegistry;
12456 }
12457 ITagAliasRegistry const& getTagAliasRegistry() const override {
12458 return m_tagAliasRegistry;
12459 }
12460 StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
12461 return m_exceptionRegistry;
12462 }
12463
12464 public: // IMutableRegistryHub
12465 void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
12466 m_reporterRegistry.registerReporter( name, factory );
12467 }
12468 void registerListener( IReporterFactoryPtr const& factory ) override {
12469 m_reporterRegistry.registerListener( factory );
12470 }
12471 void registerTest( TestCase const& testInfo ) override {
12472 m_testCaseRegistry.registerTest( testInfo );
12473 }
12474 void registerTranslator( const IExceptionTranslator* translator ) override {
12475 m_exceptionTranslatorRegistry.registerTranslator( translator );
12476 }
12477 void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
12478 m_tagAliasRegistry.add( alias, tag, lineInfo );
12479 }
12480 void registerStartupException() noexcept override {
12481 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
12482 m_exceptionRegistry.add(std::current_exception());
12483 #else
12484 CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
12485 #endif
12486 }
12487 IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
12488 return m_enumValuesRegistry;
12489 }
12490
12491 private:
12492 TestRegistry m_testCaseRegistry;
12493 ReporterRegistry m_reporterRegistry;
12494 ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
12495 TagAliasRegistry m_tagAliasRegistry;
12496 StartupExceptionRegistry m_exceptionRegistry;
12497 Detail::EnumValuesRegistry m_enumValuesRegistry;
12498 };
12499 }
12500
12501 using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
12502
12503 IRegistryHub const& getRegistryHub() {
12504 return RegistryHubSingleton::get();
12505 }
12506 IMutableRegistryHub& getMutableRegistryHub() {
12507 return RegistryHubSingleton::getMutable();
12508 }
12509 void cleanUp() {
12510 cleanupSingletons();
12511 cleanUpContext();
12512 }
12513 std::string translateActiveException() {
12514 return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
12515 }
12516
12517 } // end namespace Catch
12518 // end catch_registry_hub.cpp
12519 // start catch_reporter_registry.cpp
12520
12521 namespace Catch {
12522
12523 ReporterRegistry::~ReporterRegistry() = default;
12524
12525 IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
12526 auto it = m_factories.find( name );
12527 if( it == m_factories.end() )
12528 return nullptr;
12529 return it->second->create( ReporterConfig( config ) );
12530 }
12531
12532 void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
12533 m_factories.emplace(name, factory);
12534 }
12535 void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
12536 m_listeners.push_back( factory );
12537 }
12538
12539 IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
12540 return m_factories;
12541 }
12542 IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
12543 return m_listeners;
12544 }
12545
12546 }
12547 // end catch_reporter_registry.cpp
12548 // start catch_result_type.cpp
12549
12550 namespace Catch {
12551
12552 bool isOk( ResultWas::OfType resultType ) {
12553 return ( resultType & ResultWas::FailureBit ) == 0;
12554 }
12555 bool isJustInfo( int flags ) {
12556 return flags == ResultWas::Info;
12557 }
12558
12559 ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
12560 return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
12561 }
12562
12563 bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
12564 bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; }
12565
12566 } // end namespace Catch
12567 // end catch_result_type.cpp
12568 // start catch_run_context.cpp
12569
12570 #include <cassert>
12571 #include <algorithm>
12572 #include <sstream>
12573
12574 namespace Catch {
12575
12576 namespace Generators {
12577 struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
12578 GeneratorBasePtr m_generator;
12579
12580 GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
12581 : TrackerBase( nameAndLocation, ctx, parent )
12582 {}
12583 ~GeneratorTracker();
12584
12585 static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
12586 std::shared_ptr<GeneratorTracker> tracker;
12587
12588 ITracker& currentTracker = ctx.currentTracker();
12589 // Under specific circumstances, the generator we want
12590 // to acquire is also the current tracker. If this is
12591 // the case, we have to avoid looking through current
12592 // tracker's children, and instead return the current
12593 // tracker.
12594 // A case where this check is important is e.g.
12595 // for (int i = 0; i < 5; ++i) {
12596 // int n = GENERATE(1, 2);
12597 // }
12598 //
12599 // without it, the code above creates 5 nested generators.
12600 if (currentTracker.nameAndLocation() == nameAndLocation) {
12601 auto thisTracker = currentTracker.parent().findChild(nameAndLocation);
12602 assert(thisTracker);
12603 assert(thisTracker->isGeneratorTracker());
12604 tracker = std::static_pointer_cast<GeneratorTracker>(thisTracker);
12605 } else if ( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
12606 assert( childTracker );
12607 assert( childTracker->isGeneratorTracker() );
12608 tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
12609 } else {
12610 tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
12611 currentTracker.addChild( tracker );
12612 }
12613
12614 if( !tracker->isComplete() ) {
12615 tracker->open();
12616 }
12617
12618 return *tracker;
12619 }
12620
12621 // TrackerBase interface
12622 bool isGeneratorTracker() const override { return true; }
12623 auto hasGenerator() const -> bool override {
12624 return !!m_generator;
12625 }
12626 void close() override {
12627 TrackerBase::close();
12628 // If a generator has a child (it is followed by a section)
12629 // and none of its children have started, then we must wait
12630 // until later to start consuming its values.
12631 // This catches cases where `GENERATE` is placed between two
12632 // `SECTION`s.
12633 // **The check for m_children.empty cannot be removed**.
12634 // doing so would break `GENERATE` _not_ followed by `SECTION`s.
12635 const bool should_wait_for_child = [&]() {
12636 // No children -> nobody to wait for
12637 if ( m_children.empty() ) {
12638 return false;
12639 }
12640 // If at least one child started executing, don't wait
12641 if ( std::find_if(
12642 m_children.begin(),
12643 m_children.end(),
12644 []( TestCaseTracking::ITrackerPtr tracker ) {
12645 return tracker->hasStarted();
12646 } ) != m_children.end() ) {
12647 return false;
12648 }
12649
12650 // No children have started. We need to check if they _can_
12651 // start, and thus we should wait for them, or they cannot
12652 // start (due to filters), and we shouldn't wait for them
12653 auto* parent = m_parent;
12654 // This is safe: there is always at least one section
12655 // tracker in a test case tracking tree
12656 while ( !parent->isSectionTracker() ) {
12657 parent = &( parent->parent() );
12658 }
12659 assert( parent &&
12660 "Missing root (test case) level section" );
12661
12662 auto const& parentSection =
12663 static_cast<SectionTracker&>( *parent );
12664 auto const& filters = parentSection.getFilters();
12665 // No filters -> no restrictions on running sections
12666 if ( filters.empty() ) {
12667 return true;
12668 }
12669
12670 for ( auto const& child : m_children ) {
12671 if ( child->isSectionTracker() &&
12672 std::find( filters.begin(),
12673 filters.end(),
12674 static_cast<SectionTracker&>( *child )
12675 .trimmedName() ) !=
12676 filters.end() ) {
12677 return true;
12678 }
12679 }
12680 return false;
12681 }();
12682
12683 // This check is a bit tricky, because m_generator->next()
12684 // has a side-effect, where it consumes generator's current
12685 // value, but we do not want to invoke the side-effect if
12686 // this generator is still waiting for any child to start.
12687 if ( should_wait_for_child ||
12688 ( m_runState == CompletedSuccessfully &&
12689 m_generator->next() ) ) {
12690 m_children.clear();
12691 m_runState = Executing;
12692 }
12693 }
12694
12695 // IGeneratorTracker interface
12696 auto getGenerator() const -> GeneratorBasePtr const& override {
12697 return m_generator;
12698 }
12699 void setGenerator( GeneratorBasePtr&& generator ) override {
12700 m_generator = std::move( generator );
12701 }
12702 };
12703 GeneratorTracker::~GeneratorTracker() {}
12704 }
12705
12706 RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
12707 : m_runInfo(_config->name()),
12708 m_context(getCurrentMutableContext()),
12709 m_config(_config),
12710 m_reporter(std::move(reporter)),
12711 m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
12712 m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
12713 {
12714 m_context.setRunner(this);
12715 m_context.setConfig(m_config);
12716 m_context.setResultCapture(this);
12717 m_reporter->testRunStarting(m_runInfo);
12718 }
12719
12720 RunContext::~RunContext() {
12721 m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
12722 }
12723
12724 void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
12725 m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
12726 }
12727
12728 void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
12729 m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
12730 }
12731
12732 Totals RunContext::runTest(TestCase const& testCase) {
12733 Totals prevTotals = m_totals;
12734
12735 std::string redirectedCout;
12736 std::string redirectedCerr;
12737
12738 auto const& testInfo = testCase.getTestCaseInfo();
12739
12740 m_reporter->testCaseStarting(testInfo);
12741
12742 m_activeTestCase = &testCase;
12743
12744 ITracker& rootTracker = m_trackerContext.startRun();
12745 assert(rootTracker.isSectionTracker());
12746 static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
12747 do {
12748 m_trackerContext.startCycle();
12749 m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
12750 runCurrentTest(redirectedCout, redirectedCerr);
12751 } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
12752
12753 Totals deltaTotals = m_totals.delta(prevTotals);
12754 if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
12755 deltaTotals.assertions.failed++;
12756 deltaTotals.testCases.passed--;
12757 deltaTotals.testCases.failed++;
12758 }
12759 m_totals.testCases += deltaTotals.testCases;
12760 m_reporter->testCaseEnded(TestCaseStats(testInfo,
12761 deltaTotals,
12762 redirectedCout,
12763 redirectedCerr,
12764 aborting()));
12765
12766 m_activeTestCase = nullptr;
12767 m_testCaseTracker = nullptr;
12768
12769 return deltaTotals;
12770 }
12771
12772 IConfigPtr RunContext::config() const {
12773 return m_config;
12774 }
12775
12776 IStreamingReporter& RunContext::reporter() const {
12777 return *m_reporter;
12778 }
12779
12780 void RunContext::assertionEnded(AssertionResult const & result) {
12781 if (result.getResultType() == ResultWas::Ok) {
12782 m_totals.assertions.passed++;
12783 m_lastAssertionPassed = true;
12784 } else if (!result.isOk()) {
12785 m_lastAssertionPassed = false;
12786 if( m_activeTestCase->getTestCaseInfo().okToFail() )
12787 m_totals.assertions.failedButOk++;
12788 else
12789 m_totals.assertions.failed++;
12790 }
12791 else {
12792 m_lastAssertionPassed = true;
12793 }
12794
12795 // We have no use for the return value (whether messages should be cleared), because messages were made scoped
12796 // and should be let to clear themselves out.
12797 static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
12798
12799 if (result.getResultType() != ResultWas::Warning)
12800 m_messageScopes.clear();
12801
12802 // Reset working state
12803 resetAssertionInfo();
12804 m_lastResult = result;
12805 }
12806 void RunContext::resetAssertionInfo() {
12807 m_lastAssertionInfo.macroName = StringRef();
12808 m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
12809 }
12810
12811 bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
12812 ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
12813 if (!sectionTracker.isOpen())
12814 return false;
12815 m_activeSections.push_back(&sectionTracker);
12816
12817 m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
12818
12819 m_reporter->sectionStarting(sectionInfo);
12820
12821 assertions = m_totals.assertions;
12822
12823 return true;
12824 }
12825 auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
12826 using namespace Generators;
12827 GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
12828 TestCaseTracking::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
12829 m_lastAssertionInfo.lineInfo = lineInfo;
12830 return tracker;
12831 }
12832
12833 bool RunContext::testForMissingAssertions(Counts& assertions) {
12834 if (assertions.total() != 0)
12835 return false;
12836 if (!m_config->warnAboutMissingAssertions())
12837 return false;
12838 if (m_trackerContext.currentTracker().hasChildren())
12839 return false;
12840 m_totals.assertions.failed++;
12841 assertions.failed++;
12842 return true;
12843 }
12844
12845 void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
12846 Counts assertions = m_totals.assertions - endInfo.prevAssertions;
12847 bool missingAssertions = testForMissingAssertions(assertions);
12848
12849 if (!m_activeSections.empty()) {
12850 m_activeSections.back()->close();
12851 m_activeSections.pop_back();
12852 }
12853
12854 m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
12855 m_messages.clear();
12856 m_messageScopes.clear();
12857 }
12858
12859 void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
12860 if (m_unfinishedSections.empty())
12861 m_activeSections.back()->fail();
12862 else
12863 m_activeSections.back()->close();
12864 m_activeSections.pop_back();
12865
12866 m_unfinishedSections.push_back(endInfo);
12867 }
12868
12869 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
12870 void RunContext::benchmarkPreparing(std::string const& name) {
12871 m_reporter->benchmarkPreparing(name);
12872 }
12873 void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
12874 m_reporter->benchmarkStarting( info );
12875 }
12876 void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
12877 m_reporter->benchmarkEnded( stats );
12878 }
12879 void RunContext::benchmarkFailed(std::string const & error) {
12880 m_reporter->benchmarkFailed(error);
12881 }
12882 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
12883
12884 void RunContext::pushScopedMessage(MessageInfo const & message) {
12885 m_messages.push_back(message);
12886 }
12887
12888 void RunContext::popScopedMessage(MessageInfo const & message) {
12889 m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
12890 }
12891
12892 void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
12893 m_messageScopes.emplace_back( builder );
12894 }
12895
12896 std::string RunContext::getCurrentTestName() const {
12897 return m_activeTestCase
12898 ? m_activeTestCase->getTestCaseInfo().name
12899 : std::string();
12900 }
12901
12902 const AssertionResult * RunContext::getLastResult() const {
12903 return &(*m_lastResult);
12904 }
12905
12906 void RunContext::exceptionEarlyReported() {
12907 m_shouldReportUnexpected = false;
12908 }
12909
12910 void RunContext::handleFatalErrorCondition( StringRef message ) {
12911 // First notify reporter that bad things happened
12912 m_reporter->fatalErrorEncountered(message);
12913
12914 // Don't rebuild the result -- the stringification itself can cause more fatal errors
12915 // Instead, fake a result data.
12916 AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
12917 tempResult.message = static_cast<std::string>(message);
12918 AssertionResult result(m_lastAssertionInfo, tempResult);
12919
12920 assertionEnded(result);
12921
12922 handleUnfinishedSections();
12923
12924 // Recreate section for test case (as we will lose the one that was in scope)
12925 auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
12926 SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
12927
12928 Counts assertions;
12929 assertions.failed = 1;
12930 SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
12931 m_reporter->sectionEnded(testCaseSectionStats);
12932
12933 auto const& testInfo = m_activeTestCase->getTestCaseInfo();
12934
12935 Totals deltaTotals;
12936 deltaTotals.testCases.failed = 1;
12937 deltaTotals.assertions.failed = 1;
12938 m_reporter->testCaseEnded(TestCaseStats(testInfo,
12939 deltaTotals,
12940 std::string(),
12941 std::string(),
12942 false));
12943 m_totals.testCases.failed++;
12944 testGroupEnded(std::string(), m_totals, 1, 1);
12945 m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
12946 }
12947
12948 bool RunContext::lastAssertionPassed() {
12949 return m_lastAssertionPassed;
12950 }
12951
12952 void RunContext::assertionPassed() {
12953 m_lastAssertionPassed = true;
12954 ++m_totals.assertions.passed;
12955 resetAssertionInfo();
12956 m_messageScopes.clear();
12957 }
12958
12959 bool RunContext::aborting() const {
12960 return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
12961 }
12962
12963 void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
12964 auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
12965 SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
12966 m_reporter->sectionStarting(testCaseSection);
12967 Counts prevAssertions = m_totals.assertions;
12968 double duration = 0;
12969 m_shouldReportUnexpected = true;
12970 m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
12971
12972 seedRng(*m_config);
12973
12974 Timer timer;
12975 CATCH_TRY {
12976 if (m_reporter->getPreferences().shouldRedirectStdOut) {
12977 #if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
12978 RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
12979
12980 timer.start();
12981 invokeActiveTestCase();
12982 #else
12983 OutputRedirect r(redirectedCout, redirectedCerr);
12984 timer.start();
12985 invokeActiveTestCase();
12986 #endif
12987 } else {
12988 timer.start();
12989 invokeActiveTestCase();
12990 }
12991 duration = timer.getElapsedSeconds();
12992 } CATCH_CATCH_ANON (TestFailureException&) {
12993 // This just means the test was aborted due to failure
12994 } CATCH_CATCH_ALL {
12995 // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
12996 // are reported without translation at the point of origin.
12997 if( m_shouldReportUnexpected ) {
12998 AssertionReaction dummyReaction;
12999 handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
13000 }
13001 }
13002 Counts assertions = m_totals.assertions - prevAssertions;
13003 bool missingAssertions = testForMissingAssertions(assertions);
13004
13005 m_testCaseTracker->close();
13006 handleUnfinishedSections();
13007 m_messages.clear();
13008 m_messageScopes.clear();
13009
13010 SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
13011 m_reporter->sectionEnded(testCaseSectionStats);
13012 }
13013
13014 void RunContext::invokeActiveTestCase() {
13015 FatalConditionHandlerGuard _(&m_fatalConditionhandler);
13016 m_activeTestCase->invoke();
13017 }
13018
13019 void RunContext::handleUnfinishedSections() {
13020 // If sections ended prematurely due to an exception we stored their
13021 // infos here so we can tear them down outside the unwind process.
13022 for (auto it = m_unfinishedSections.rbegin(),
13023 itEnd = m_unfinishedSections.rend();
13024 it != itEnd;
13025 ++it)
13026 sectionEnded(*it);
13027 m_unfinishedSections.clear();
13028 }
13029
13030 void RunContext::handleExpr(
13031 AssertionInfo const& info,
13032 ITransientExpression const& expr,
13033 AssertionReaction& reaction
13034 ) {
13035 m_reporter->assertionStarting( info );
13036
13037 bool negated = isFalseTest( info.resultDisposition );
13038 bool result = expr.getResult() != negated;
13039
13040 if( result ) {
13041 if (!m_includeSuccessfulResults) {
13042 assertionPassed();
13043 }
13044 else {
13045 reportExpr(info, ResultWas::Ok, &expr, negated);
13046 }
13047 }
13048 else {
13049 reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
13050 populateReaction( reaction );
13051 }
13052 }
13053 void RunContext::reportExpr(
13054 AssertionInfo const &info,
13055 ResultWas::OfType resultType,
13056 ITransientExpression const *expr,
13057 bool negated ) {
13058
13059 m_lastAssertionInfo = info;
13060 AssertionResultData data( resultType, LazyExpression( negated ) );
13061
13062 AssertionResult assertionResult{ info, data };
13063 assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
13064
13065 assertionEnded( assertionResult );
13066 }
13067
13068 void RunContext::handleMessage(
13069 AssertionInfo const& info,
13070 ResultWas::OfType resultType,
13071 StringRef const& message,
13072 AssertionReaction& reaction
13073 ) {
13074 m_reporter->assertionStarting( info );
13075
13076 m_lastAssertionInfo = info;
13077
13078 AssertionResultData data( resultType, LazyExpression( false ) );
13079 data.message = static_cast<std::string>(message);
13080 AssertionResult assertionResult{ m_lastAssertionInfo, data };
13081 assertionEnded( assertionResult );
13082 if( !assertionResult.isOk() )
13083 populateReaction( reaction );
13084 }
13085 void RunContext::handleUnexpectedExceptionNotThrown(
13086 AssertionInfo const& info,
13087 AssertionReaction& reaction
13088 ) {
13089 handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
13090 }
13091
13092 void RunContext::handleUnexpectedInflightException(
13093 AssertionInfo const& info,
13094 std::string const& message,
13095 AssertionReaction& reaction
13096 ) {
13097 m_lastAssertionInfo = info;
13098
13099 AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
13100 data.message = message;
13101 AssertionResult assertionResult{ info, data };
13102 assertionEnded( assertionResult );
13103 populateReaction( reaction );
13104 }
13105
13106 void RunContext::populateReaction( AssertionReaction& reaction ) {
13107 reaction.shouldDebugBreak = m_config->shouldDebugBreak();
13108 reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
13109 }
13110
13111 void RunContext::handleIncomplete(
13112 AssertionInfo const& info
13113 ) {
13114 m_lastAssertionInfo = info;
13115
13116 AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
13117 data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
13118 AssertionResult assertionResult{ info, data };
13119 assertionEnded( assertionResult );
13120 }
13121 void RunContext::handleNonExpr(
13122 AssertionInfo const &info,
13123 ResultWas::OfType resultType,
13124 AssertionReaction &reaction
13125 ) {
13126 m_lastAssertionInfo = info;
13127
13128 AssertionResultData data( resultType, LazyExpression( false ) );
13129 AssertionResult assertionResult{ info, data };
13130 assertionEnded( assertionResult );
13131
13132 if( !assertionResult.isOk() )
13133 populateReaction( reaction );
13134 }
13135
13136 IResultCapture& getResultCapture() {
13137 if (auto* capture = getCurrentContext().getResultCapture())
13138 return *capture;
13139 else
13140 CATCH_INTERNAL_ERROR("No result capture instance");
13141 }
13142
13143 void seedRng(IConfig const& config) {
13144 if (config.rngSeed() != 0) {
13145 std::srand(config.rngSeed());
13146 rng().seed(config.rngSeed());
13147 }
13148 }
13149
13150 unsigned int rngSeed() {
13151 return getCurrentContext().getConfig()->rngSeed();
13152 }
13153
13154 }
13155 // end catch_run_context.cpp
13156 // start catch_section.cpp
13157
13158 namespace Catch {
13159
13160 Section::Section( SectionInfo const& info )
13161 : m_info( info ),
13162 m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
13163 {
13164 m_timer.start();
13165 }
13166
13167 Section::~Section() {
13168 if( m_sectionIncluded ) {
13169 SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
13170 if( uncaught_exceptions() )
13171 getResultCapture().sectionEndedEarly( endInfo );
13172 else
13173 getResultCapture().sectionEnded( endInfo );
13174 }
13175 }
13176
13177 // This indicates whether the section should be executed or not
13178 Section::operator bool() const {
13179 return m_sectionIncluded;
13180 }
13181
13182 } // end namespace Catch
13183 // end catch_section.cpp
13184 // start catch_section_info.cpp
13185
13186 namespace Catch {
13187
13188 SectionInfo::SectionInfo
13189 ( SourceLineInfo const& _lineInfo,
13190 std::string const& _name )
13191 : name( _name ),
13192 lineInfo( _lineInfo )
13193 {}
13194
13195 } // end namespace Catch
13196 // end catch_section_info.cpp
13197 // start catch_session.cpp
13198
13199 // start catch_session.h
13200
13201 #include <memory>
13202
13203 namespace Catch {
13204
13205 class Session : NonCopyable {
13206 public:
13207
13208 Session();
13209 ~Session() override;
13210
13211 void showHelp() const;
13212 void libIdentify();
13213
13214 int applyCommandLine( int argc, char const * const * argv );
13215 #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
13216 int applyCommandLine( int argc, wchar_t const * const * argv );
13217 #endif
13218
13219 void useConfigData( ConfigData const& configData );
13220
13221 template<typename CharT>
13222 int run(int argc, CharT const * const argv[]) {
13223 if (m_startupExceptions)
13224 return 1;
13225 int returnCode = applyCommandLine(argc, argv);
13226 if (returnCode == 0)
13227 returnCode = run();
13228 return returnCode;
13229 }
13230
13231 int run();
13232
13233 clara::Parser const& cli() const;
13234 void cli( clara::Parser const& newParser );
13235 ConfigData& configData();
13236 Config& config();
13237 private:
13238 int runInternal();
13239
13240 clara::Parser m_cli;
13241 ConfigData m_configData;
13242 std::shared_ptr<Config> m_config;
13243 bool m_startupExceptions = false;
13244 };
13245
13246 } // end namespace Catch
13247
13248 // end catch_session.h
13249 // start catch_version.h
13250
13251 #include <iosfwd>
13252
13253 namespace Catch {
13254
13255 // Versioning information
13256 struct Version {
13257 Version( Version const& ) = delete;
13258 Version& operator=( Version const& ) = delete;
13259 Version( unsigned int _majorVersion,
13260 unsigned int _minorVersion,
13261 unsigned int _patchNumber,
13262 char const * const _branchName,
13263 unsigned int _buildNumber );
13264
13265 unsigned int const majorVersion;
13266 unsigned int const minorVersion;
13267 unsigned int const patchNumber;
13268
13269 // buildNumber is only used if branchName is not null
13270 char const * const branchName;
13271 unsigned int const buildNumber;
13272
13273 friend std::ostream& operator << ( std::ostream& os, Version const& version );
13274 };
13275
13276 Version const& libraryVersion();
13277 }
13278
13279 // end catch_version.h
13280 #include <cstdlib>
13281 #include <iomanip>
13282 #include <set>
13283 #include <iterator>
13284
13285 namespace Catch {
13286
13287 namespace {
13288 const int MaxExitCode = 255;
13289
13290 IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
13291 auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
13292 CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
13293
13294 return reporter;
13295 }
13296
13297 IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
13298 if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
13299 return createReporter(config->getReporterName(), config);
13300 }
13301
13302 // On older platforms, returning std::unique_ptr<ListeningReporter>
13303 // when the return type is std::unique_ptr<IStreamingReporter>
13304 // doesn't compile without a std::move call. However, this causes
13305 // a warning on newer platforms. Thus, we have to work around
13306 // it a bit and downcast the pointer manually.
13307 auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
13308 auto& multi = static_cast<ListeningReporter&>(*ret);
13309 auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
13310 for (auto const& listener : listeners) {
13311 multi.addListener(listener->create(Catch::ReporterConfig(config)));
13312 }
13313 multi.addReporter(createReporter(config->getReporterName(), config));
13314 return ret;
13315 }
13316
13317 class TestGroup {
13318 public:
13319 explicit TestGroup(std::shared_ptr<Config> const& config)
13320 : m_config{config}
13321 , m_context{config, makeReporter(config)}
13322 {
13323 auto const& allTestCases = getAllTestCasesSorted(*m_config);
13324 m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
13325 auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
13326
13327 if (m_matches.empty() && invalidArgs.empty()) {
13328 for (auto const& test : allTestCases)
13329 if (!test.isHidden())
13330 m_tests.emplace(&test);
13331 } else {
13332 for (auto const& match : m_matches)
13333 m_tests.insert(match.tests.begin(), match.tests.end());
13334 }
13335 }
13336
13337 Totals execute() {
13338 auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
13339 Totals totals;
13340 m_context.testGroupStarting(m_config->name(), 1, 1);
13341 for (auto const& testCase : m_tests) {
13342 if (!m_context.aborting())
13343 totals += m_context.runTest(*testCase);
13344 else
13345 m_context.reporter().skipTest(*testCase);
13346 }
13347
13348 for (auto const& match : m_matches) {
13349 if (match.tests.empty()) {
13350 m_context.reporter().noMatchingTestCases(match.name);
13351 totals.error = -1;
13352 }
13353 }
13354
13355 if (!invalidArgs.empty()) {
13356 for (auto const& invalidArg: invalidArgs)
13357 m_context.reporter().reportInvalidArguments(invalidArg);
13358 }
13359
13360 m_context.testGroupEnded(m_config->name(), totals, 1, 1);
13361 return totals;
13362 }
13363
13364 private:
13365 using Tests = std::set<TestCase const*>;
13366
13367 std::shared_ptr<Config> m_config;
13368 RunContext m_context;
13369 Tests m_tests;
13370 TestSpec::Matches m_matches;
13371 };
13372
13373 void applyFilenamesAsTags(Catch::IConfig const& config) {
13374 auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
13375 for (auto& testCase : tests) {
13376 auto tags = testCase.tags;
13377
13378 std::string filename = testCase.lineInfo.file;
13379 auto lastSlash = filename.find_last_of("\\/");
13380 if (lastSlash != std::string::npos) {
13381 filename.erase(0, lastSlash);
13382 filename[0] = '#';
13383 }
13384
13385 auto lastDot = filename.find_last_of('.');
13386 if (lastDot != std::string::npos) {
13387 filename.erase(lastDot);
13388 }
13389
13390 tags.push_back(std::move(filename));
13391 setTags(testCase, tags);
13392 }
13393 }
13394
13395 } // anon namespace
13396
13397 Session::Session() {
13398 static bool alreadyInstantiated = false;
13399 if( alreadyInstantiated ) {
13400 CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
13401 CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
13402 }
13403
13404 // There cannot be exceptions at startup in no-exception mode.
13405 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
13406 const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
13407 if ( !exceptions.empty() ) {
13408 config();
13409 getCurrentMutableContext().setConfig(m_config);
13410
13411 m_startupExceptions = true;
13412 Colour colourGuard( Colour::Red );
13413 Catch::cerr() << "Errors occurred during startup!" << '\n';
13414 // iterate over all exceptions and notify user
13415 for ( const auto& ex_ptr : exceptions ) {
13416 try {
13417 std::rethrow_exception(ex_ptr);
13418 } catch ( std::exception const& ex ) {
13419 Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
13420 }
13421 }
13422 }
13423 #endif
13424
13425 alreadyInstantiated = true;
13426 m_cli = makeCommandLineParser( m_configData );
13427 }
13428 Session::~Session() {
13429 Catch::cleanUp();
13430 }
13431
13432 void Session::showHelp() const {
13433 Catch::cout()
13434 << "\nCatch v" << libraryVersion() << "\n"
13435 << m_cli << std::endl
13436 << "For more detailed usage please see the project docs\n" << std::endl;
13437 }
13438 void Session::libIdentify() {
13439 Catch::cout()
13440 << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
13441 << std::left << std::setw(16) << "category: " << "testframework\n"
13442 << std::left << std::setw(16) << "framework: " << "Catch Test\n"
13443 << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
13444 }
13445
13446 int Session::applyCommandLine( int argc, char const * const * argv ) {
13447 if( m_startupExceptions )
13448 return 1;
13449
13450 auto result = m_cli.parse( clara::Args( argc, argv ) );
13451 if( !result ) {
13452 config();
13453 getCurrentMutableContext().setConfig(m_config);
13454 Catch::cerr()
13455 << Colour( Colour::Red )
13456 << "\nError(s) in input:\n"
13457 << Column( result.errorMessage() ).indent( 2 )
13458 << "\n\n";
13459 Catch::cerr() << "Run with -? for usage\n" << std::endl;
13460 return MaxExitCode;
13461 }
13462
13463 if( m_configData.showHelp )
13464 showHelp();
13465 if( m_configData.libIdentify )
13466 libIdentify();
13467 m_config.reset();
13468 return 0;
13469 }
13470
13471 #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
13472 int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
13473
13474 char **utf8Argv = new char *[ argc ];
13475
13476 for ( int i = 0; i < argc; ++i ) {
13477 int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
13478
13479 utf8Argv[ i ] = new char[ bufSize ];
13480
13481 WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
13482 }
13483
13484 int returnCode = applyCommandLine( argc, utf8Argv );
13485
13486 for ( int i = 0; i < argc; ++i )
13487 delete [] utf8Argv[ i ];
13488
13489 delete [] utf8Argv;
13490
13491 return returnCode;
13492 }
13493 #endif
13494
13495 void Session::useConfigData( ConfigData const& configData ) {
13496 m_configData = configData;
13497 m_config.reset();
13498 }
13499
13500 int Session::run() {
13501 if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
13502 Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
13503 static_cast<void>(std::getchar());
13504 }
13505 int exitCode = runInternal();
13506 if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
13507 Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
13508 static_cast<void>(std::getchar());
13509 }
13510 return exitCode;
13511 }
13512
13513 clara::Parser const& Session::cli() const {
13514 return m_cli;
13515 }
13516 void Session::cli( clara::Parser const& newParser ) {
13517 m_cli = newParser;
13518 }
13519 ConfigData& Session::configData() {
13520 return m_configData;
13521 }
13522 Config& Session::config() {
13523 if( !m_config )
13524 m_config = std::make_shared<Config>( m_configData );
13525 return *m_config;
13526 }
13527
13528 int Session::runInternal() {
13529 if( m_startupExceptions )
13530 return 1;
13531
13532 if (m_configData.showHelp || m_configData.libIdentify) {
13533 return 0;
13534 }
13535
13536 CATCH_TRY {
13537 config(); // Force config to be constructed
13538
13539 seedRng( *m_config );
13540
13541 if( m_configData.filenamesAsTags )
13542 applyFilenamesAsTags( *m_config );
13543
13544 // Handle list request
13545 if( Option<std::size_t> listed = list( m_config ) )
13546 return static_cast<int>( *listed );
13547
13548 TestGroup tests { m_config };
13549 auto const totals = tests.execute();
13550
13551 if( m_config->warnAboutNoTests() && totals.error == -1 )
13552 return 2;
13553
13554 // Note that on unices only the lower 8 bits are usually used, clamping
13555 // the return value to 255 prevents false negative when some multiple
13556 // of 256 tests has failed
13557 return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
13558 }
13559 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
13560 catch( std::exception& ex ) {
13561 Catch::cerr() << ex.what() << std::endl;
13562 return MaxExitCode;
13563 }
13564 #endif
13565 }
13566
13567 } // end namespace Catch
13568 // end catch_session.cpp
13569 // start catch_singletons.cpp
13570
13571 #include <vector>
13572
13573 namespace Catch {
13574
13575 namespace {
13576 static auto getSingletons() -> std::vector<ISingleton*>*& {
13577 static std::vector<ISingleton*>* g_singletons = nullptr;
13578 if( !g_singletons )
13579 g_singletons = new std::vector<ISingleton*>();
13580 return g_singletons;
13581 }
13582 }
13583
13584 ISingleton::~ISingleton() {}
13585
13586 void addSingleton(ISingleton* singleton ) {
13587 getSingletons()->push_back( singleton );
13588 }
13589 void cleanupSingletons() {
13590 auto& singletons = getSingletons();
13591 for( auto singleton : *singletons )
13592 delete singleton;
13593 delete singletons;
13594 singletons = nullptr;
13595 }
13596
13597 } // namespace Catch
13598 // end catch_singletons.cpp
13599 // start catch_startup_exception_registry.cpp
13600
13601 #if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
13602 namespace Catch {
13603 void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
13604 CATCH_TRY {
13605 m_exceptions.push_back(exception);
13606 } CATCH_CATCH_ALL {
13607 // If we run out of memory during start-up there's really not a lot more we can do about it
13608 std::terminate();
13609 }
13610 }
13611
13612 std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
13613 return m_exceptions;
13614 }
13615
13616 } // end namespace Catch
13617 #endif
13618 // end catch_startup_exception_registry.cpp
13619 // start catch_stream.cpp
13620
13621 #include <cstdio>
13622 #include <iostream>
13623 #include <fstream>
13624 #include <sstream>
13625 #include <vector>
13626 #include <memory>
13627
13628 namespace Catch {
13629
13630 Catch::IStream::~IStream() = default;
13631
13632 namespace Detail { namespace {
13633 template<typename WriterF, std::size_t bufferSize=256>
13634 class StreamBufImpl : public std::streambuf {
13635 char data[bufferSize];
13636 WriterF m_writer;
13637
13638 public:
13639 StreamBufImpl() {
13640 setp( data, data + sizeof(data) );
13641 }
13642
13643 ~StreamBufImpl() noexcept {
13644 StreamBufImpl::sync();
13645 }
13646
13647 private:
13648 int overflow( int c ) override {
13649 sync();
13650
13651 if( c != EOF ) {
13652 if( pbase() == epptr() )
13653 m_writer( std::string( 1, static_cast<char>( c ) ) );
13654 else
13655 sputc( static_cast<char>( c ) );
13656 }
13657 return 0;
13658 }
13659
13660 int sync() override {
13661 if( pbase() != pptr() ) {
13662 m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
13663 setp( pbase(), epptr() );
13664 }
13665 return 0;
13666 }
13667 };
13668
13669 ///////////////////////////////////////////////////////////////////////////
13670
13671 struct OutputDebugWriter {
13672
13673 void operator()( std::string const&str ) {
13674 writeToDebugConsole( str );
13675 }
13676 };
13677
13678 ///////////////////////////////////////////////////////////////////////////
13679
13680 class FileStream : public IStream {
13681 mutable std::ofstream m_ofs;
13682 public:
13683 FileStream( StringRef filename ) {
13684 m_ofs.open( filename.c_str() );
13685 CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
13686 }
13687 ~FileStream() override = default;
13688 public: // IStream
13689 std::ostream& stream() const override {
13690 return m_ofs;
13691 }
13692 };
13693
13694 ///////////////////////////////////////////////////////////////////////////
13695
13696 class CoutStream : public IStream {
13697 mutable std::ostream m_os;
13698 public:
13699 // Store the streambuf from cout up-front because
13700 // cout may get redirected when running tests
13701 CoutStream() : m_os( Catch::cout().rdbuf() ) {}
13702 ~CoutStream() override = default;
13703
13704 public: // IStream
13705 std::ostream& stream() const override { return m_os; }
13706 };
13707
13708 ///////////////////////////////////////////////////////////////////////////
13709
13710 class DebugOutStream : public IStream {
13711 std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
13712 mutable std::ostream m_os;
13713 public:
13714 DebugOutStream()
13715 : m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
13716 m_os( m_streamBuf.get() )
13717 {}
13718
13719 ~DebugOutStream() override = default;
13720
13721 public: // IStream
13722 std::ostream& stream() const override { return m_os; }
13723 };
13724
13725 }} // namespace anon::detail
13726
13727 ///////////////////////////////////////////////////////////////////////////
13728
13729 auto makeStream( StringRef const &filename ) -> IStream const* {
13730 if( filename.empty() )
13731 return new Detail::CoutStream();
13732 else if( filename[0] == '%' ) {
13733 if( filename == "%debug" )
13734 return new Detail::DebugOutStream();
13735 else
13736 CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
13737 }
13738 else
13739 return new Detail::FileStream( filename );
13740 }
13741
13742 // This class encapsulates the idea of a pool of ostringstreams that can be reused.
13743 struct StringStreams {
13744 std::vector<std::unique_ptr<std::ostringstream>> m_streams;
13745 std::vector<std::size_t> m_unused;
13746 std::ostringstream m_referenceStream; // Used for copy state/ flags from
13747
13748 auto add() -> std::size_t {
13749 if( m_unused.empty() ) {
13750 m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
13751 return m_streams.size()-1;
13752 }
13753 else {
13754 auto index = m_unused.back();
13755 m_unused.pop_back();
13756 return index;
13757 }
13758 }
13759
13760 void release( std::size_t index ) {
13761 m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
13762 m_unused.push_back(index);
13763 }
13764 };
13765
13766 ReusableStringStream::ReusableStringStream()
13767 : m_index( Singleton<StringStreams>::getMutable().add() ),
13768 m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
13769 {}
13770
13771 ReusableStringStream::~ReusableStringStream() {
13772 static_cast<std::ostringstream*>( m_oss )->str("");
13773 m_oss->clear();
13774 Singleton<StringStreams>::getMutable().release( m_index );
13775 }
13776
13777 auto ReusableStringStream::str() const -> std::string {
13778 return static_cast<std::ostringstream*>( m_oss )->str();
13779 }
13780
13781 ///////////////////////////////////////////////////////////////////////////
13782
13783 #ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
13784 std::ostream& cout() { return std::cout; }
13785 std::ostream& cerr() { return std::cerr; }
13786 std::ostream& clog() { return std::clog; }
13787 #endif
13788 }
13789 // end catch_stream.cpp
13790 // start catch_string_manip.cpp
13791
13792 #include <algorithm>
13793 #include <ostream>
13794 #include <cstring>
13795 #include <cctype>
13796 #include <vector>
13797
13798 namespace Catch {
13799
13800 namespace {
13801 char toLowerCh(char c) {
13802 return static_cast<char>( std::tolower( static_cast<unsigned char>(c) ) );
13803 }
13804 }
13805
13806 bool startsWith( std::string const& s, std::string const& prefix ) {
13807 return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
13808 }
13809 bool startsWith( std::string const& s, char prefix ) {
13810 return !s.empty() && s[0] == prefix;
13811 }
13812 bool endsWith( std::string const& s, std::string const& suffix ) {
13813 return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
13814 }
13815 bool endsWith( std::string const& s, char suffix ) {
13816 return !s.empty() && s[s.size()-1] == suffix;
13817 }
13818 bool contains( std::string const& s, std::string const& infix ) {
13819 return s.find( infix ) != std::string::npos;
13820 }
13821 void toLowerInPlace( std::string& s ) {
13822 std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
13823 }
13824 std::string toLower( std::string const& s ) {
13825 std::string lc = s;
13826 toLowerInPlace( lc );
13827 return lc;
13828 }
13829 std::string trim( std::string const& str ) {
13830 static char const* whitespaceChars = "\n\r\t ";
13831 std::string::size_type start = str.find_first_not_of( whitespaceChars );
13832 std::string::size_type end = str.find_last_not_of( whitespaceChars );
13833
13834 return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
13835 }
13836
13837 StringRef trim(StringRef ref) {
13838 const auto is_ws = [](char c) {
13839 return c == ' ' || c == '\t' || c == '\n' || c == '\r';
13840 };
13841 size_t real_begin = 0;
13842 while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
13843 size_t real_end = ref.size();
13844 while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
13845
13846 return ref.substr(real_begin, real_end - real_begin);
13847 }
13848
13849 bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
13850 bool replaced = false;
13851 std::size_t i = str.find( replaceThis );
13852 while( i != std::string::npos ) {
13853 replaced = true;
13854 str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
13855 if( i < str.size()-withThis.size() )
13856 i = str.find( replaceThis, i+withThis.size() );
13857 else
13858 i = std::string::npos;
13859 }
13860 return replaced;
13861 }
13862
13863 std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
13864 std::vector<StringRef> subStrings;
13865 std::size_t start = 0;
13866 for(std::size_t pos = 0; pos < str.size(); ++pos ) {
13867 if( str[pos] == delimiter ) {
13868 if( pos - start > 1 )
13869 subStrings.push_back( str.substr( start, pos-start ) );
13870 start = pos+1;
13871 }
13872 }
13873 if( start < str.size() )
13874 subStrings.push_back( str.substr( start, str.size()-start ) );
13875 return subStrings;
13876 }
13877
13878 pluralise::pluralise( std::size_t count, std::string const& label )
13879 : m_count( count ),
13880 m_label( label )
13881 {}
13882
13883 std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
13884 os << pluraliser.m_count << ' ' << pluraliser.m_label;
13885 if( pluraliser.m_count != 1 )
13886 os << 's';
13887 return os;
13888 }
13889
13890 }
13891 // end catch_string_manip.cpp
13892 // start catch_stringref.cpp
13893
13894 #include <algorithm>
13895 #include <ostream>
13896 #include <cstring>
13897 #include <cstdint>
13898
13899 namespace Catch {
13900 StringRef::StringRef( char const* rawChars ) noexcept
13901 : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
13902 {}
13903
13904 auto StringRef::c_str() const -> char const* {
13905 CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
13906 return m_start;
13907 }
13908 auto StringRef::data() const noexcept -> char const* {
13909 return m_start;
13910 }
13911
13912 auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
13913 if (start < m_size) {
13914 return StringRef(m_start + start, (std::min)(m_size - start, size));
13915 } else {
13916 return StringRef();
13917 }
13918 }
13919 auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
13920 return m_size == other.m_size
13921 && (std::memcmp( m_start, other.m_start, m_size ) == 0);
13922 }
13923
13924 auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
13925 return os.write(str.data(), str.size());
13926 }
13927
13928 auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
13929 lhs.append(rhs.data(), rhs.size());
13930 return lhs;
13931 }
13932
13933 } // namespace Catch
13934 // end catch_stringref.cpp
13935 // start catch_tag_alias.cpp
13936
13937 namespace Catch {
13938 TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
13939 }
13940 // end catch_tag_alias.cpp
13941 // start catch_tag_alias_autoregistrar.cpp
13942
13943 namespace Catch {
13944
13945 RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
13946 CATCH_TRY {
13947 getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
13948 } CATCH_CATCH_ALL {
13949 // Do not throw when constructing global objects, instead register the exception to be processed later
13950 getMutableRegistryHub().registerStartupException();
13951 }
13952 }
13953
13954 }
13955 // end catch_tag_alias_autoregistrar.cpp
13956 // start catch_tag_alias_registry.cpp
13957
13958 #include <sstream>
13959
13960 namespace Catch {
13961
13962 TagAliasRegistry::~TagAliasRegistry() {}
13963
13964 TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
13965 auto it = m_registry.find( alias );
13966 if( it != m_registry.end() )
13967 return &(it->second);
13968 else
13969 return nullptr;
13970 }
13971
13972 std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
13973 std::string expandedTestSpec = unexpandedTestSpec;
13974 for( auto const& registryKvp : m_registry ) {
13975 std::size_t pos = expandedTestSpec.find( registryKvp.first );
13976 if( pos != std::string::npos ) {
13977 expandedTestSpec = expandedTestSpec.substr( 0, pos ) +
13978 registryKvp.second.tag +
13979 expandedTestSpec.substr( pos + registryKvp.first.size() );
13980 }
13981 }
13982 return expandedTestSpec;
13983 }
13984
13985 void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
13986 CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
13987 "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
13988
13989 CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
13990 "error: tag alias, '" << alias << "' already registered.\n"
13991 << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
13992 << "\tRedefined at: " << lineInfo );
13993 }
13994
13995 ITagAliasRegistry::~ITagAliasRegistry() {}
13996
13997 ITagAliasRegistry const& ITagAliasRegistry::get() {
13998 return getRegistryHub().getTagAliasRegistry();
13999 }
14000
14001 } // end namespace Catch
14002 // end catch_tag_alias_registry.cpp
14003 // start catch_test_case_info.cpp
14004
14005 #include <cctype>
14006 #include <exception>
14007 #include <algorithm>
14008 #include <sstream>
14009
14010 namespace Catch {
14011
14012 namespace {
14013 TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
14014 if( startsWith( tag, '.' ) ||
14015 tag == "!hide" )
14016 return TestCaseInfo::IsHidden;
14017 else if( tag == "!throws" )
14018 return TestCaseInfo::Throws;
14019 else if( tag == "!shouldfail" )
14020 return TestCaseInfo::ShouldFail;
14021 else if( tag == "!mayfail" )
14022 return TestCaseInfo::MayFail;
14023 else if( tag == "!nonportable" )
14024 return TestCaseInfo::NonPortable;
14025 else if( tag == "!benchmark" )
14026 return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
14027 else
14028 return TestCaseInfo::None;
14029 }
14030 bool isReservedTag( std::string const& tag ) {
14031 return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
14032 }
14033 void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
14034 CATCH_ENFORCE( !isReservedTag(tag),
14035 "Tag name: [" << tag << "] is not allowed.\n"
14036 << "Tag names starting with non alphanumeric characters are reserved\n"
14037 << _lineInfo );
14038 }
14039 }
14040
14041 TestCase makeTestCase( ITestInvoker* _testCase,
14042 std::string const& _className,
14043 NameAndTags const& nameAndTags,
14044 SourceLineInfo const& _lineInfo )
14045 {
14046 bool isHidden = false;
14047
14048 // Parse out tags
14049 std::vector<std::string> tags;
14050 std::string desc, tag;
14051 bool inTag = false;
14052 for (char c : nameAndTags.tags) {
14053 if( !inTag ) {
14054 if( c == '[' )
14055 inTag = true;
14056 else
14057 desc += c;
14058 }
14059 else {
14060 if( c == ']' ) {
14061 TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
14062 if( ( prop & TestCaseInfo::IsHidden ) != 0 )
14063 isHidden = true;
14064 else if( prop == TestCaseInfo::None )
14065 enforceNotReservedTag( tag, _lineInfo );
14066
14067 // Merged hide tags like `[.approvals]` should be added as
14068 // `[.][approvals]`. The `[.]` is added at later point, so
14069 // we only strip the prefix
14070 if (startsWith(tag, '.') && tag.size() > 1) {
14071 tag.erase(0, 1);
14072 }
14073 tags.push_back( tag );
14074 tag.clear();
14075 inTag = false;
14076 }
14077 else
14078 tag += c;
14079 }
14080 }
14081 if( isHidden ) {
14082 // Add all "hidden" tags to make them behave identically
14083 tags.insert( tags.end(), { ".", "!hide" } );
14084 }
14085
14086 TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
14087 return TestCase( _testCase, std::move(info) );
14088 }
14089
14090 void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
14091 std::sort(begin(tags), end(tags));
14092 tags.erase(std::unique(begin(tags), end(tags)), end(tags));
14093 testCaseInfo.lcaseTags.clear();
14094
14095 for( auto const& tag : tags ) {
14096 std::string lcaseTag = toLower( tag );
14097 testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
14098 testCaseInfo.lcaseTags.push_back( lcaseTag );
14099 }
14100 testCaseInfo.tags = std::move(tags);
14101 }
14102
14103 TestCaseInfo::TestCaseInfo( std::string const& _name,
14104 std::string const& _className,
14105 std::string const& _description,
14106 std::vector<std::string> const& _tags,
14107 SourceLineInfo const& _lineInfo )
14108 : name( _name ),
14109 className( _className ),
14110 description( _description ),
14111 lineInfo( _lineInfo ),
14112 properties( None )
14113 {
14114 setTags( *this, _tags );
14115 }
14116
14117 bool TestCaseInfo::isHidden() const {
14118 return ( properties & IsHidden ) != 0;
14119 }
14120 bool TestCaseInfo::throws() const {
14121 return ( properties & Throws ) != 0;
14122 }
14123 bool TestCaseInfo::okToFail() const {
14124 return ( properties & (ShouldFail | MayFail ) ) != 0;
14125 }
14126 bool TestCaseInfo::expectedToFail() const {
14127 return ( properties & (ShouldFail ) ) != 0;
14128 }
14129
14130 std::string TestCaseInfo::tagsAsString() const {
14131 std::string ret;
14132 // '[' and ']' per tag
14133 std::size_t full_size = 2 * tags.size();
14134 for (const auto& tag : tags) {
14135 full_size += tag.size();
14136 }
14137 ret.reserve(full_size);
14138 for (const auto& tag : tags) {
14139 ret.push_back('[');
14140 ret.append(tag);
14141 ret.push_back(']');
14142 }
14143
14144 return ret;
14145 }
14146
14147 TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
14148
14149 TestCase TestCase::withName( std::string const& _newName ) const {
14150 TestCase other( *this );
14151 other.name = _newName;
14152 return other;
14153 }
14154
14155 void TestCase::invoke() const {
14156 test->invoke();
14157 }
14158
14159 bool TestCase::operator == ( TestCase const& other ) const {
14160 return test.get() == other.test.get() &&
14161 name == other.name &&
14162 className == other.className;
14163 }
14164
14165 bool TestCase::operator < ( TestCase const& other ) const {
14166 return name < other.name;
14167 }
14168
14169 TestCaseInfo const& TestCase::getTestCaseInfo() const
14170 {
14171 return *this;
14172 }
14173
14174 } // end namespace Catch
14175 // end catch_test_case_info.cpp
14176 // start catch_test_case_registry_impl.cpp
14177
14178 #include <algorithm>
14179 #include <sstream>
14180
14181 namespace Catch {
14182
14183 namespace {
14184 struct TestHasher {
14185 using hash_t = uint64_t;
14186
14187 explicit TestHasher( hash_t hashSuffix ):
14188 m_hashSuffix{ hashSuffix } {}
14189
14190 uint32_t operator()( TestCase const& t ) const {
14191 // FNV-1a hash with multiplication fold.
14192 const hash_t prime = 1099511628211u;
14193 hash_t hash = 14695981039346656037u;
14194 for ( const char c : t.name ) {
14195 hash ^= c;
14196 hash *= prime;
14197 }
14198 hash ^= m_hashSuffix;
14199 hash *= prime;
14200 const uint32_t low{ static_cast<uint32_t>( hash ) };
14201 const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
14202 return low * high;
14203 }
14204
14205 private:
14206 hash_t m_hashSuffix;
14207 };
14208 } // end unnamed namespace
14209
14210 std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
14211 switch( config.runOrder() ) {
14212 case RunTests::InDeclarationOrder:
14213 // already in declaration order
14214 break;
14215
14216 case RunTests::InLexicographicalOrder: {
14217 std::vector<TestCase> sorted = unsortedTestCases;
14218 std::sort( sorted.begin(), sorted.end() );
14219 return sorted;
14220 }
14221
14222 case RunTests::InRandomOrder: {
14223 seedRng( config );
14224 TestHasher h{ config.rngSeed() };
14225
14226 using hashedTest = std::pair<TestHasher::hash_t, TestCase const*>;
14227 std::vector<hashedTest> indexed_tests;
14228 indexed_tests.reserve( unsortedTestCases.size() );
14229
14230 for (auto const& testCase : unsortedTestCases) {
14231 indexed_tests.emplace_back(h(testCase), &testCase);
14232 }
14233
14234 std::sort(indexed_tests.begin(), indexed_tests.end(),
14235 [](hashedTest const& lhs, hashedTest const& rhs) {
14236 if (lhs.first == rhs.first) {
14237 return lhs.second->name < rhs.second->name;
14238 }
14239 return lhs.first < rhs.first;
14240 });
14241
14242 std::vector<TestCase> sorted;
14243 sorted.reserve( indexed_tests.size() );
14244
14245 for (auto const& hashed : indexed_tests) {
14246 sorted.emplace_back(*hashed.second);
14247 }
14248
14249 return sorted;
14250 }
14251 }
14252 return unsortedTestCases;
14253 }
14254
14255 bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
14256 return !testCase.throws() || config.allowThrows();
14257 }
14258
14259 bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
14260 return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
14261 }
14262
14263 void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
14264 std::set<TestCase> seenFunctions;
14265 for( auto const& function : functions ) {
14266 auto prev = seenFunctions.insert( function );
14267 CATCH_ENFORCE( prev.second,
14268 "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
14269 << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
14270 << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
14271 }
14272 }
14273
14274 std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
14275 std::vector<TestCase> filtered;
14276 filtered.reserve( testCases.size() );
14277 for (auto const& testCase : testCases) {
14278 if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
14279 (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
14280 filtered.push_back(testCase);
14281 }
14282 }
14283 return filtered;
14284 }
14285 std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
14286 return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
14287 }
14288
14289 void TestRegistry::registerTest( TestCase const& testCase ) {
14290 std::string name = testCase.getTestCaseInfo().name;
14291 if( name.empty() ) {
14292 ReusableStringStream rss;
14293 rss << "Anonymous test case " << ++m_unnamedCount;
14294 return registerTest( testCase.withName( rss.str() ) );
14295 }
14296 m_functions.push_back( testCase );
14297 }
14298
14299 std::vector<TestCase> const& TestRegistry::getAllTests() const {
14300 return m_functions;
14301 }
14302 std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
14303 if( m_sortedFunctions.empty() )
14304 enforceNoDuplicateTestCases( m_functions );
14305
14306 if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
14307 m_sortedFunctions = sortTests( config, m_functions );
14308 m_currentSortOrder = config.runOrder();
14309 }
14310 return m_sortedFunctions;
14311 }
14312
14313 ///////////////////////////////////////////////////////////////////////////
14314 TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
14315
14316 void TestInvokerAsFunction::invoke() const {
14317 m_testAsFunction();
14318 }
14319
14320 std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
14321 std::string className(classOrQualifiedMethodName);
14322 if( startsWith( className, '&' ) )
14323 {
14324 std::size_t lastColons = className.rfind( "::" );
14325 std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
14326 if( penultimateColons == std::string::npos )
14327 penultimateColons = 1;
14328 className = className.substr( penultimateColons, lastColons-penultimateColons );
14329 }
14330 return className;
14331 }
14332
14333 } // end namespace Catch
14334 // end catch_test_case_registry_impl.cpp
14335 // start catch_test_case_tracker.cpp
14336
14337 #include <algorithm>
14338 #include <cassert>
14339 #include <stdexcept>
14340 #include <memory>
14341 #include <sstream>
14342
14343 #if defined(__clang__)
14344 # pragma clang diagnostic push
14345 # pragma clang diagnostic ignored "-Wexit-time-destructors"
14346 #endif
14347
14348 namespace Catch {
14349 namespace TestCaseTracking {
14350
14351 NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
14352 : name( _name ),
14353 location( _location )
14354 {}
14355
14356 ITracker::~ITracker() = default;
14357
14358 ITracker& TrackerContext::startRun() {
14359 m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
14360 m_currentTracker = nullptr;
14361 m_runState = Executing;
14362 return *m_rootTracker;
14363 }
14364
14365 void TrackerContext::endRun() {
14366 m_rootTracker.reset();
14367 m_currentTracker = nullptr;
14368 m_runState = NotStarted;
14369 }
14370
14371 void TrackerContext::startCycle() {
14372 m_currentTracker = m_rootTracker.get();
14373 m_runState = Executing;
14374 }
14375 void TrackerContext::completeCycle() {
14376 m_runState = CompletedCycle;
14377 }
14378
14379 bool TrackerContext::completedCycle() const {
14380 return m_runState == CompletedCycle;
14381 }
14382 ITracker& TrackerContext::currentTracker() {
14383 return *m_currentTracker;
14384 }
14385 void TrackerContext::setCurrentTracker( ITracker* tracker ) {
14386 m_currentTracker = tracker;
14387 }
14388
14389 TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
14390 ITracker(nameAndLocation),
14391 m_ctx( ctx ),
14392 m_parent( parent )
14393 {}
14394
14395 bool TrackerBase::isComplete() const {
14396 return m_runState == CompletedSuccessfully || m_runState == Failed;
14397 }
14398 bool TrackerBase::isSuccessfullyCompleted() const {
14399 return m_runState == CompletedSuccessfully;
14400 }
14401 bool TrackerBase::isOpen() const {
14402 return m_runState != NotStarted && !isComplete();
14403 }
14404 bool TrackerBase::hasChildren() const {
14405 return !m_children.empty();
14406 }
14407
14408 void TrackerBase::addChild( ITrackerPtr const& child ) {
14409 m_children.push_back( child );
14410 }
14411
14412 ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
14413 auto it = std::find_if( m_children.begin(), m_children.end(),
14414 [&nameAndLocation]( ITrackerPtr const& tracker ){
14415 return
14416 tracker->nameAndLocation().location == nameAndLocation.location &&
14417 tracker->nameAndLocation().name == nameAndLocation.name;
14418 } );
14419 return( it != m_children.end() )
14420 ? *it
14421 : nullptr;
14422 }
14423 ITracker& TrackerBase::parent() {
14424 assert( m_parent ); // Should always be non-null except for root
14425 return *m_parent;
14426 }
14427
14428 void TrackerBase::openChild() {
14429 if( m_runState != ExecutingChildren ) {
14430 m_runState = ExecutingChildren;
14431 if( m_parent )
14432 m_parent->openChild();
14433 }
14434 }
14435
14436 bool TrackerBase::isSectionTracker() const { return false; }
14437 bool TrackerBase::isGeneratorTracker() const { return false; }
14438
14439 void TrackerBase::open() {
14440 m_runState = Executing;
14441 moveToThis();
14442 if( m_parent )
14443 m_parent->openChild();
14444 }
14445
14446 void TrackerBase::close() {
14447
14448 // Close any still open children (e.g. generators)
14449 while( &m_ctx.currentTracker() != this )
14450 m_ctx.currentTracker().close();
14451
14452 switch( m_runState ) {
14453 case NeedsAnotherRun:
14454 break;
14455
14456 case Executing:
14457 m_runState = CompletedSuccessfully;
14458 break;
14459 case ExecutingChildren:
14460 if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
14461 m_runState = CompletedSuccessfully;
14462 break;
14463
14464 case NotStarted:
14465 case CompletedSuccessfully:
14466 case Failed:
14467 CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
14468
14469 default:
14470 CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
14471 }
14472 moveToParent();
14473 m_ctx.completeCycle();
14474 }
14475 void TrackerBase::fail() {
14476 m_runState = Failed;
14477 if( m_parent )
14478 m_parent->markAsNeedingAnotherRun();
14479 moveToParent();
14480 m_ctx.completeCycle();
14481 }
14482 void TrackerBase::markAsNeedingAnotherRun() {
14483 m_runState = NeedsAnotherRun;
14484 }
14485
14486 void TrackerBase::moveToParent() {
14487 assert( m_parent );
14488 m_ctx.setCurrentTracker( m_parent );
14489 }
14490 void TrackerBase::moveToThis() {
14491 m_ctx.setCurrentTracker( this );
14492 }
14493
14494 SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
14495 : TrackerBase( nameAndLocation, ctx, parent ),
14496 m_trimmed_name(trim(nameAndLocation.name))
14497 {
14498 if( parent ) {
14499 while( !parent->isSectionTracker() )
14500 parent = &parent->parent();
14501
14502 SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
14503 addNextFilters( parentSection.m_filters );
14504 }
14505 }
14506
14507 bool SectionTracker::isComplete() const {
14508 bool complete = true;
14509
14510 if (m_filters.empty()
14511 || m_filters[0] == ""
14512 || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
14513 complete = TrackerBase::isComplete();
14514 }
14515 return complete;
14516 }
14517
14518 bool SectionTracker::isSectionTracker() const { return true; }
14519
14520 SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
14521 std::shared_ptr<SectionTracker> section;
14522
14523 ITracker& currentTracker = ctx.currentTracker();
14524 if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
14525 assert( childTracker );
14526 assert( childTracker->isSectionTracker() );
14527 section = std::static_pointer_cast<SectionTracker>( childTracker );
14528 }
14529 else {
14530 section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
14531 currentTracker.addChild( section );
14532 }
14533 if( !ctx.completedCycle() )
14534 section->tryOpen();
14535 return *section;
14536 }
14537
14538 void SectionTracker::tryOpen() {
14539 if( !isComplete() )
14540 open();
14541 }
14542
14543 void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
14544 if( !filters.empty() ) {
14545 m_filters.reserve( m_filters.size() + filters.size() + 2 );
14546 m_filters.emplace_back(""); // Root - should never be consulted
14547 m_filters.emplace_back(""); // Test Case - not a section filter
14548 m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
14549 }
14550 }
14551 void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
14552 if( filters.size() > 1 )
14553 m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
14554 }
14555
14556 std::vector<std::string> const& SectionTracker::getFilters() const {
14557 return m_filters;
14558 }
14559
14560 std::string const& SectionTracker::trimmedName() const {
14561 return m_trimmed_name;
14562 }
14563
14564 } // namespace TestCaseTracking
14565
14566 using TestCaseTracking::ITracker;
14567 using TestCaseTracking::TrackerContext;
14568 using TestCaseTracking::SectionTracker;
14569
14570 } // namespace Catch
14571
14572 #if defined(__clang__)
14573 # pragma clang diagnostic pop
14574 #endif
14575 // end catch_test_case_tracker.cpp
14576 // start catch_test_registry.cpp
14577
14578 namespace Catch {
14579
14580 auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
14581 return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
14582 }
14583
14584 NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
14585
14586 AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
14587 CATCH_TRY {
14588 getMutableRegistryHub()
14589 .registerTest(
14590 makeTestCase(
14591 invoker,
14592 extractClassName( classOrMethod ),
14593 nameAndTags,
14594 lineInfo));
14595 } CATCH_CATCH_ALL {
14596 // Do not throw when constructing global objects, instead register the exception to be processed later
14597 getMutableRegistryHub().registerStartupException();
14598 }
14599 }
14600
14601 AutoReg::~AutoReg() = default;
14602 }
14603 // end catch_test_registry.cpp
14604 // start catch_test_spec.cpp
14605
14606 #include <algorithm>
14607 #include <string>
14608 #include <vector>
14609 #include <memory>
14610
14611 namespace Catch {
14612
14613 TestSpec::Pattern::Pattern( std::string const& name )
14614 : m_name( name )
14615 {}
14616
14617 TestSpec::Pattern::~Pattern() = default;
14618
14619 std::string const& TestSpec::Pattern::name() const {
14620 return m_name;
14621 }
14622
14623 TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
14624 : Pattern( filterString )
14625 , m_wildcardPattern( toLower( name ), CaseSensitive::No )
14626 {}
14627
14628 bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
14629 return m_wildcardPattern.matches( testCase.name );
14630 }
14631
14632 TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
14633 : Pattern( filterString )
14634 , m_tag( toLower( tag ) )
14635 {}
14636
14637 bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
14638 return std::find(begin(testCase.lcaseTags),
14639 end(testCase.lcaseTags),
14640 m_tag) != end(testCase.lcaseTags);
14641 }
14642
14643 TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
14644 : Pattern( underlyingPattern->name() )
14645 , m_underlyingPattern( underlyingPattern )
14646 {}
14647
14648 bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
14649 return !m_underlyingPattern->matches( testCase );
14650 }
14651
14652 bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
14653 return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
14654 }
14655
14656 std::string TestSpec::Filter::name() const {
14657 std::string name;
14658 for( auto const& p : m_patterns )
14659 name += p->name();
14660 return name;
14661 }
14662
14663 bool TestSpec::hasFilters() const {
14664 return !m_filters.empty();
14665 }
14666
14667 bool TestSpec::matches( TestCaseInfo const& testCase ) const {
14668 return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
14669 }
14670
14671 TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
14672 {
14673 Matches matches( m_filters.size() );
14674 std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
14675 std::vector<TestCase const*> currentMatches;
14676 for( auto const& test : testCases )
14677 if( isThrowSafe( test, config ) && filter.matches( test ) )
14678 currentMatches.emplace_back( &test );
14679 return FilterMatch{ filter.name(), currentMatches };
14680 } );
14681 return matches;
14682 }
14683
14684 const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
14685 return (m_invalidArgs);
14686 }
14687
14688 }
14689 // end catch_test_spec.cpp
14690 // start catch_test_spec_parser.cpp
14691
14692 namespace Catch {
14693
14694 TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
14695
14696 TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
14697 m_mode = None;
14698 m_exclusion = false;
14699 m_arg = m_tagAliases->expandAliases( arg );
14700 m_escapeChars.clear();
14701 m_substring.reserve(m_arg.size());
14702 m_patternName.reserve(m_arg.size());
14703 m_realPatternPos = 0;
14704
14705 for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
14706 //if visitChar fails
14707 if( !visitChar( m_arg[m_pos] ) ){
14708 m_testSpec.m_invalidArgs.push_back(arg);
14709 break;
14710 }
14711 endMode();
14712 return *this;
14713 }
14714 TestSpec TestSpecParser::testSpec() {
14715 addFilter();
14716 return m_testSpec;
14717 }
14718 bool TestSpecParser::visitChar( char c ) {
14719 if( (m_mode != EscapedName) && (c == '\\') ) {
14720 escape();
14721 addCharToPattern(c);
14722 return true;
14723 }else if((m_mode != EscapedName) && (c == ',') ) {
14724 return separate();
14725 }
14726
14727 switch( m_mode ) {
14728 case None:
14729 if( processNoneChar( c ) )
14730 return true;
14731 break;
14732 case Name:
14733 processNameChar( c );
14734 break;
14735 case EscapedName:
14736 endMode();
14737 addCharToPattern(c);
14738 return true;
14739 default:
14740 case Tag:
14741 case QuotedName:
14742 if( processOtherChar( c ) )
14743 return true;
14744 break;
14745 }
14746
14747 m_substring += c;
14748 if( !isControlChar( c ) ) {
14749 m_patternName += c;
14750 m_realPatternPos++;
14751 }
14752 return true;
14753 }
14754 // Two of the processing methods return true to signal the caller to return
14755 // without adding the given character to the current pattern strings
14756 bool TestSpecParser::processNoneChar( char c ) {
14757 switch( c ) {
14758 case ' ':
14759 return true;
14760 case '~':
14761 m_exclusion = true;
14762 return false;
14763 case '[':
14764 startNewMode( Tag );
14765 return false;
14766 case '"':
14767 startNewMode( QuotedName );
14768 return false;
14769 default:
14770 startNewMode( Name );
14771 return false;
14772 }
14773 }
14774 void TestSpecParser::processNameChar( char c ) {
14775 if( c == '[' ) {
14776 if( m_substring == "exclude:" )
14777 m_exclusion = true;
14778 else
14779 endMode();
14780 startNewMode( Tag );
14781 }
14782 }
14783 bool TestSpecParser::processOtherChar( char c ) {
14784 if( !isControlChar( c ) )
14785 return false;
14786 m_substring += c;
14787 endMode();
14788 return true;
14789 }
14790 void TestSpecParser::startNewMode( Mode mode ) {
14791 m_mode = mode;
14792 }
14793 void TestSpecParser::endMode() {
14794 switch( m_mode ) {
14795 case Name:
14796 case QuotedName:
14797 return addNamePattern();
14798 case Tag:
14799 return addTagPattern();
14800 case EscapedName:
14801 revertBackToLastMode();
14802 return;
14803 case None:
14804 default:
14805 return startNewMode( None );
14806 }
14807 }
14808 void TestSpecParser::escape() {
14809 saveLastMode();
14810 m_mode = EscapedName;
14811 m_escapeChars.push_back(m_realPatternPos);
14812 }
14813 bool TestSpecParser::isControlChar( char c ) const {
14814 switch( m_mode ) {
14815 default:
14816 return false;
14817 case None:
14818 return c == '~';
14819 case Name:
14820 return c == '[';
14821 case EscapedName:
14822 return true;
14823 case QuotedName:
14824 return c == '"';
14825 case Tag:
14826 return c == '[' || c == ']';
14827 }
14828 }
14829
14830 void TestSpecParser::addFilter() {
14831 if( !m_currentFilter.m_patterns.empty() ) {
14832 m_testSpec.m_filters.push_back( m_currentFilter );
14833 m_currentFilter = TestSpec::Filter();
14834 }
14835 }
14836
14837 void TestSpecParser::saveLastMode() {
14838 lastMode = m_mode;
14839 }
14840
14841 void TestSpecParser::revertBackToLastMode() {
14842 m_mode = lastMode;
14843 }
14844
14845 bool TestSpecParser::separate() {
14846 if( (m_mode==QuotedName) || (m_mode==Tag) ){
14847 //invalid argument, signal failure to previous scope.
14848 m_mode = None;
14849 m_pos = m_arg.size();
14850 m_substring.clear();
14851 m_patternName.clear();
14852 m_realPatternPos = 0;
14853 return false;
14854 }
14855 endMode();
14856 addFilter();
14857 return true; //success
14858 }
14859
14860 std::string TestSpecParser::preprocessPattern() {
14861 std::string token = m_patternName;
14862 for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
14863 token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
14864 m_escapeChars.clear();
14865 if (startsWith(token, "exclude:")) {
14866 m_exclusion = true;
14867 token = token.substr(8);
14868 }
14869
14870 m_patternName.clear();
14871 m_realPatternPos = 0;
14872
14873 return token;
14874 }
14875
14876 void TestSpecParser::addNamePattern() {
14877 auto token = preprocessPattern();
14878
14879 if (!token.empty()) {
14880 TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
14881 if (m_exclusion)
14882 pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
14883 m_currentFilter.m_patterns.push_back(pattern);
14884 }
14885 m_substring.clear();
14886 m_exclusion = false;
14887 m_mode = None;
14888 }
14889
14890 void TestSpecParser::addTagPattern() {
14891 auto token = preprocessPattern();
14892
14893 if (!token.empty()) {
14894 // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
14895 // we have to create a separate hide tag and shorten the real one
14896 if (token.size() > 1 && token[0] == '.') {
14897 token.erase(token.begin());
14898 TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
14899 if (m_exclusion) {
14900 pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
14901 }
14902 m_currentFilter.m_patterns.push_back(pattern);
14903 }
14904
14905 TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
14906
14907 if (m_exclusion) {
14908 pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
14909 }
14910 m_currentFilter.m_patterns.push_back(pattern);
14911 }
14912 m_substring.clear();
14913 m_exclusion = false;
14914 m_mode = None;
14915 }
14916
14917 TestSpec parseTestSpec( std::string const& arg ) {
14918 return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
14919 }
14920
14921 } // namespace Catch
14922 // end catch_test_spec_parser.cpp
14923 // start catch_timer.cpp
14924
14925 #include <chrono>
14926
14927 static const uint64_t nanosecondsInSecond = 1000000000;
14928
14929 namespace Catch {
14930
14931 auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
14932 return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
14933 }
14934
14935 namespace {
14936 auto estimateClockResolution() -> uint64_t {
14937 uint64_t sum = 0;
14938 static const uint64_t iterations = 1000000;
14939
14940 auto startTime = getCurrentNanosecondsSinceEpoch();
14941
14942 for( std::size_t i = 0; i < iterations; ++i ) {
14943
14944 uint64_t ticks;
14945 uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
14946 do {
14947 ticks = getCurrentNanosecondsSinceEpoch();
14948 } while( ticks == baseTicks );
14949
14950 auto delta = ticks - baseTicks;
14951 sum += delta;
14952
14953 // If we have been calibrating for over 3 seconds -- the clock
14954 // is terrible and we should move on.
14955 // TBD: How to signal that the measured resolution is probably wrong?
14956 if (ticks > startTime + 3 * nanosecondsInSecond) {
14957 return sum / ( i + 1u );
14958 }
14959 }
14960
14961 // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
14962 // - and potentially do more iterations if there's a high variance.
14963 return sum/iterations;
14964 }
14965 }
14966 auto getEstimatedClockResolution() -> uint64_t {
14967 static auto s_resolution = estimateClockResolution();
14968 return s_resolution;
14969 }
14970
14971 void Timer::start() {
14972 m_nanoseconds = getCurrentNanosecondsSinceEpoch();
14973 }
14974 auto Timer::getElapsedNanoseconds() const -> uint64_t {
14975 return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
14976 }
14977 auto Timer::getElapsedMicroseconds() const -> uint64_t {
14978 return getElapsedNanoseconds()/1000;
14979 }
14980 auto Timer::getElapsedMilliseconds() const -> unsigned int {
14981 return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
14982 }
14983 auto Timer::getElapsedSeconds() const -> double {
14984 return getElapsedMicroseconds()/1000000.0;
14985 }
14986
14987 } // namespace Catch
14988 // end catch_timer.cpp
14989 // start catch_tostring.cpp
14990
14991 #if defined(__clang__)
14992 # pragma clang diagnostic push
14993 # pragma clang diagnostic ignored "-Wexit-time-destructors"
14994 # pragma clang diagnostic ignored "-Wglobal-constructors"
14995 #endif
14996
14997 // Enable specific decls locally
14998 #if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
14999 #define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
15000 #endif
15001
15002 #include <cmath>
15003 #include <iomanip>
15004
15005 namespace Catch {
15006
15007 namespace Detail {
15008
15009 const std::string unprintableString = "{?}";
15010
15011 namespace {
15012 const int hexThreshold = 255;
15013
15014 struct Endianness {
15015 enum Arch { Big, Little };
15016
15017 static Arch which() {
15018 int one = 1;
15019 // If the lowest byte we read is non-zero, we can assume
15020 // that little endian format is used.
15021 auto value = *reinterpret_cast<char*>(&one);
15022 return value ? Little : Big;
15023 }
15024 };
15025 }
15026
15027 std::string rawMemoryToString( const void *object, std::size_t size ) {
15028 // Reverse order for little endian architectures
15029 int i = 0, end = static_cast<int>( size ), inc = 1;
15030 if( Endianness::which() == Endianness::Little ) {
15031 i = end-1;
15032 end = inc = -1;
15033 }
15034
15035 unsigned char const *bytes = static_cast<unsigned char const *>(object);
15036 ReusableStringStream rss;
15037 rss << "0x" << std::setfill('0') << std::hex;
15038 for( ; i != end; i += inc )
15039 rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
15040 return rss.str();
15041 }
15042 }
15043
15044 template<typename T>
15045 std::string fpToString( T value, int precision ) {
15046 if (Catch::isnan(value)) {
15047 return "nan";
15048 }
15049
15050 ReusableStringStream rss;
15051 rss << std::setprecision( precision )
15052 << std::fixed
15053 << value;
15054 std::string d = rss.str();
15055 std::size_t i = d.find_last_not_of( '0' );
15056 if( i != std::string::npos && i != d.size()-1 ) {
15057 if( d[i] == '.' )
15058 i++;
15059 d = d.substr( 0, i+1 );
15060 }
15061 return d;
15062 }
15063
15064 //// ======================================================= ////
15065 //
15066 // Out-of-line defs for full specialization of StringMaker
15067 //
15068 //// ======================================================= ////
15069
15070 std::string StringMaker<std::string>::convert(const std::string& str) {
15071 if (!getCurrentContext().getConfig()->showInvisibles()) {
15072 return '"' + str + '"';
15073 }
15074
15075 std::string s("\"");
15076 for (char c : str) {
15077 switch (c) {
15078 case '\n':
15079 s.append("\\n");
15080 break;
15081 case '\t':
15082 s.append("\\t");
15083 break;
15084 default:
15085 s.push_back(c);
15086 break;
15087 }
15088 }
15089 s.append("\"");
15090 return s;
15091 }
15092
15093 #ifdef CATCH_CONFIG_CPP17_STRING_VIEW
15094 std::string StringMaker<std::string_view>::convert(std::string_view str) {
15095 return ::Catch::Detail::stringify(std::string{ str });
15096 }
15097 #endif
15098
15099 std::string StringMaker<char const*>::convert(char const* str) {
15100 if (str) {
15101 return ::Catch::Detail::stringify(std::string{ str });
15102 } else {
15103 return{ "{null string}" };
15104 }
15105 }
15106 std::string StringMaker<char*>::convert(char* str) {
15107 if (str) {
15108 return ::Catch::Detail::stringify(std::string{ str });
15109 } else {
15110 return{ "{null string}" };
15111 }
15112 }
15113
15114 #ifdef CATCH_CONFIG_WCHAR
15115 std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
15116 std::string s;
15117 s.reserve(wstr.size());
15118 for (auto c : wstr) {
15119 s += (c <= 0xff) ? static_cast<char>(c) : '?';
15120 }
15121 return ::Catch::Detail::stringify(s);
15122 }
15123
15124 # ifdef CATCH_CONFIG_CPP17_STRING_VIEW
15125 std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
15126 return StringMaker<std::wstring>::convert(std::wstring(str));
15127 }
15128 # endif
15129
15130 std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
15131 if (str) {
15132 return ::Catch::Detail::stringify(std::wstring{ str });
15133 } else {
15134 return{ "{null string}" };
15135 }
15136 }
15137 std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
15138 if (str) {
15139 return ::Catch::Detail::stringify(std::wstring{ str });
15140 } else {
15141 return{ "{null string}" };
15142 }
15143 }
15144 #endif
15145
15146 #if defined(CATCH_CONFIG_CPP17_BYTE)
15147 #include <cstddef>
15148 std::string StringMaker<std::byte>::convert(std::byte value) {
15149 return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
15150 }
15151 #endif // defined(CATCH_CONFIG_CPP17_BYTE)
15152
15153 std::string StringMaker<int>::convert(int value) {
15154 return ::Catch::Detail::stringify(static_cast<long long>(value));
15155 }
15156 std::string StringMaker<long>::convert(long value) {
15157 return ::Catch::Detail::stringify(static_cast<long long>(value));
15158 }
15159 std::string StringMaker<long long>::convert(long long value) {
15160 ReusableStringStream rss;
15161 rss << value;
15162 if (value > Detail::hexThreshold) {
15163 rss << " (0x" << std::hex << value << ')';
15164 }
15165 return rss.str();
15166 }
15167
15168 std::string StringMaker<unsigned int>::convert(unsigned int value) {
15169 return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
15170 }
15171 std::string StringMaker<unsigned long>::convert(unsigned long value) {
15172 return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
15173 }
15174 std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
15175 ReusableStringStream rss;
15176 rss << value;
15177 if (value > Detail::hexThreshold) {
15178 rss << " (0x" << std::hex << value << ')';
15179 }
15180 return rss.str();
15181 }
15182
15183 std::string StringMaker<bool>::convert(bool b) {
15184 return b ? "true" : "false";
15185 }
15186
15187 std::string StringMaker<signed char>::convert(signed char value) {
15188 if (value == '\r') {
15189 return "'\\r'";
15190 } else if (value == '\f') {
15191 return "'\\f'";
15192 } else if (value == '\n') {
15193 return "'\\n'";
15194 } else if (value == '\t') {
15195 return "'\\t'";
15196 } else if ('\0' <= value && value < ' ') {
15197 return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
15198 } else {
15199 char chstr[] = "' '";
15200 chstr[1] = value;
15201 return chstr;
15202 }
15203 }
15204 std::string StringMaker<char>::convert(char c) {
15205 return ::Catch::Detail::stringify(static_cast<signed char>(c));
15206 }
15207 std::string StringMaker<unsigned char>::convert(unsigned char c) {
15208 return ::Catch::Detail::stringify(static_cast<char>(c));
15209 }
15210
15211 std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
15212 return "nullptr";
15213 }
15214
15215 int StringMaker<float>::precision = 5;
15216
15217 std::string StringMaker<float>::convert(float value) {
15218 return fpToString(value, precision) + 'f';
15219 }
15220
15221 int StringMaker<double>::precision = 10;
15222
15223 std::string StringMaker<double>::convert(double value) {
15224 return fpToString(value, precision);
15225 }
15226
15227 std::string ratio_string<std::atto>::symbol() { return "a"; }
15228 std::string ratio_string<std::femto>::symbol() { return "f"; }
15229 std::string ratio_string<std::pico>::symbol() { return "p"; }
15230 std::string ratio_string<std::nano>::symbol() { return "n"; }
15231 std::string ratio_string<std::micro>::symbol() { return "u"; }
15232 std::string ratio_string<std::milli>::symbol() { return "m"; }
15233
15234 } // end namespace Catch
15235
15236 #if defined(__clang__)
15237 # pragma clang diagnostic pop
15238 #endif
15239
15240 // end catch_tostring.cpp
15241 // start catch_totals.cpp
15242
15243 namespace Catch {
15244
15245 Counts Counts::operator - ( Counts const& other ) const {
15246 Counts diff;
15247 diff.passed = passed - other.passed;
15248 diff.failed = failed - other.failed;
15249 diff.failedButOk = failedButOk - other.failedButOk;
15250 return diff;
15251 }
15252
15253 Counts& Counts::operator += ( Counts const& other ) {
15254 passed += other.passed;
15255 failed += other.failed;
15256 failedButOk += other.failedButOk;
15257 return *this;
15258 }
15259
15260 std::size_t Counts::total() const {
15261 return passed + failed + failedButOk;
15262 }
15263 bool Counts::allPassed() const {
15264 return failed == 0 && failedButOk == 0;
15265 }
15266 bool Counts::allOk() const {
15267 return failed == 0;
15268 }
15269
15270 Totals Totals::operator - ( Totals const& other ) const {
15271 Totals diff;
15272 diff.assertions = assertions - other.assertions;
15273 diff.testCases = testCases - other.testCases;
15274 return diff;
15275 }
15276
15277 Totals& Totals::operator += ( Totals const& other ) {
15278 assertions += other.assertions;
15279 testCases += other.testCases;
15280 return *this;
15281 }
15282
15283 Totals Totals::delta( Totals const& prevTotals ) const {
15284 Totals diff = *this - prevTotals;
15285 if( diff.assertions.failed > 0 )
15286 ++diff.testCases.failed;
15287 else if( diff.assertions.failedButOk > 0 )
15288 ++diff.testCases.failedButOk;
15289 else
15290 ++diff.testCases.passed;
15291 return diff;
15292 }
15293
15294 }
15295 // end catch_totals.cpp
15296 // start catch_uncaught_exceptions.cpp
15297
15298 // start catch_config_uncaught_exceptions.hpp
15299
15300 // Copyright Catch2 Authors
15301 // Distributed under the Boost Software License, Version 1.0.
15302 // (See accompanying file LICENSE_1_0.txt or copy at
15303 // https://www.boost.org/LICENSE_1_0.txt)
15304
15305 // SPDX-License-Identifier: BSL-1.0
15306
15307 #ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
15308 #define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
15309
15310 #if defined(_MSC_VER)
15311 # if _MSC_VER >= 1900 // Visual Studio 2015 or newer
15312 # define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
15313 # endif
15314 #endif
15315
15316 #include <exception>
15317
15318 #if defined(__cpp_lib_uncaught_exceptions) \
15319 && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
15320
15321 # define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
15322 #endif // __cpp_lib_uncaught_exceptions
15323
15324 #if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
15325 && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
15326 && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
15327
15328 # define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
15329 #endif
15330
15331 #endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
15332 // end catch_config_uncaught_exceptions.hpp
15333 #include <exception>
15334
15335 namespace Catch {
15336 bool uncaught_exceptions() {
15337 #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
15338 return false;
15339 #elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
15340 return std::uncaught_exceptions() > 0;
15341 #else
15342 return std::uncaught_exception();
15343 #endif
15344 }
15345 } // end namespace Catch
15346 // end catch_uncaught_exceptions.cpp
15347 // start catch_version.cpp
15348
15349 #include <ostream>
15350
15351 namespace Catch {
15352
15353 Version::Version
15354 ( unsigned int _majorVersion,
15355 unsigned int _minorVersion,
15356 unsigned int _patchNumber,
15357 char const * const _branchName,
15358 unsigned int _buildNumber )
15359 : majorVersion( _majorVersion ),
15360 minorVersion( _minorVersion ),
15361 patchNumber( _patchNumber ),
15362 branchName( _branchName ),
15363 buildNumber( _buildNumber )
15364 {}
15365
15366 std::ostream& operator << ( std::ostream& os, Version const& version ) {
15367 os << version.majorVersion << '.'
15368 << version.minorVersion << '.'
15369 << version.patchNumber;
15370 // branchName is never null -> 0th char is \0 if it is empty
15371 if (version.branchName[0]) {
15372 os << '-' << version.branchName
15373 << '.' << version.buildNumber;
15374 }
15375 return os;
15376 }
15377
15378 Version const& libraryVersion() {
15379 static Version version( 2, 13, 6, "", 0 );
15380 return version;
15381 }
15382
15383 }
15384 // end catch_version.cpp
15385 // start catch_wildcard_pattern.cpp
15386
15387 namespace Catch {
15388
15389 WildcardPattern::WildcardPattern( std::string const& pattern,
15390 CaseSensitive::Choice caseSensitivity )
15391 : m_caseSensitivity( caseSensitivity ),
15392 m_pattern( normaliseString( pattern ) )
15393 {
15394 if( startsWith( m_pattern, '*' ) ) {
15395 m_pattern = m_pattern.substr( 1 );
15396 m_wildcard = WildcardAtStart;
15397 }
15398 if( endsWith( m_pattern, '*' ) ) {
15399 m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
15400 m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
15401 }
15402 }
15403
15404 bool WildcardPattern::matches( std::string const& str ) const {
15405 switch( m_wildcard ) {
15406 case NoWildcard:
15407 return m_pattern == normaliseString( str );
15408 case WildcardAtStart:
15409 return endsWith( normaliseString( str ), m_pattern );
15410 case WildcardAtEnd:
15411 return startsWith( normaliseString( str ), m_pattern );
15412 case WildcardAtBothEnds:
15413 return contains( normaliseString( str ), m_pattern );
15414 default:
15415 CATCH_INTERNAL_ERROR( "Unknown enum" );
15416 }
15417 }
15418
15419 std::string WildcardPattern::normaliseString( std::string const& str ) const {
15420 return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
15421 }
15422 }
15423 // end catch_wildcard_pattern.cpp
15424 // start catch_xmlwriter.cpp
15425
15426 #include <iomanip>
15427 #include <type_traits>
15428
15429 namespace Catch {
15430
15431 namespace {
15432
15433 size_t trailingBytes(unsigned char c) {
15434 if ((c & 0xE0) == 0xC0) {
15435 return 2;
15436 }
15437 if ((c & 0xF0) == 0xE0) {
15438 return 3;
15439 }
15440 if ((c & 0xF8) == 0xF0) {
15441 return 4;
15442 }
15443 CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
15444 }
15445
15446 uint32_t headerValue(unsigned char c) {
15447 if ((c & 0xE0) == 0xC0) {
15448 return c & 0x1F;
15449 }
15450 if ((c & 0xF0) == 0xE0) {
15451 return c & 0x0F;
15452 }
15453 if ((c & 0xF8) == 0xF0) {
15454 return c & 0x07;
15455 }
15456 CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
15457 }
15458
15459 void hexEscapeChar(std::ostream& os, unsigned char c) {
15460 std::ios_base::fmtflags f(os.flags());
15461 os << "\\x"
15462 << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
15463 << static_cast<int>(c);
15464 os.flags(f);
15465 }
15466
15467 bool shouldNewline(XmlFormatting fmt) {
15468 return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
15469 }
15470
15471 bool shouldIndent(XmlFormatting fmt) {
15472 return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
15473 }
15474
15475 } // anonymous namespace
15476
15477 XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
15478 return static_cast<XmlFormatting>(
15479 static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
15480 static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
15481 );
15482 }
15483
15484 XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
15485 return static_cast<XmlFormatting>(
15486 static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
15487 static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
15488 );
15489 }
15490
15491 XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
15492 : m_str( str ),
15493 m_forWhat( forWhat )
15494 {}
15495
15496 void XmlEncode::encodeTo( std::ostream& os ) const {
15497 // Apostrophe escaping not necessary if we always use " to write attributes
15498 // (see: http://www.w3.org/TR/xml/#syntax)
15499
15500 for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
15501 unsigned char c = m_str[idx];
15502 switch (c) {
15503 case '<': os << "&lt;"; break;
15504 case '&': os << "&amp;"; break;
15505
15506 case '>':
15507 // See: http://www.w3.org/TR/xml/#syntax
15508 if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
15509 os << "&gt;";
15510 else
15511 os << c;
15512 break;
15513
15514 case '\"':
15515 if (m_forWhat == ForAttributes)
15516 os << "&quot;";
15517 else
15518 os << c;
15519 break;
15520
15521 default:
15522 // Check for control characters and invalid utf-8
15523
15524 // Escape control characters in standard ascii
15525 // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
15526 if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
15527 hexEscapeChar(os, c);
15528 break;
15529 }
15530
15531 // Plain ASCII: Write it to stream
15532 if (c < 0x7F) {
15533 os << c;
15534 break;
15535 }
15536
15537 // UTF-8 territory
15538 // Check if the encoding is valid and if it is not, hex escape bytes.
15539 // Important: We do not check the exact decoded values for validity, only the encoding format
15540 // First check that this bytes is a valid lead byte:
15541 // This means that it is not encoded as 1111 1XXX
15542 // Or as 10XX XXXX
15543 if (c < 0xC0 ||
15544 c >= 0xF8) {
15545 hexEscapeChar(os, c);
15546 break;
15547 }
15548
15549 auto encBytes = trailingBytes(c);
15550 // Are there enough bytes left to avoid accessing out-of-bounds memory?
15551 if (idx + encBytes - 1 >= m_str.size()) {
15552 hexEscapeChar(os, c);
15553 break;
15554 }
15555 // The header is valid, check data
15556 // The next encBytes bytes must together be a valid utf-8
15557 // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
15558 bool valid = true;
15559 uint32_t value = headerValue(c);
15560 for (std::size_t n = 1; n < encBytes; ++n) {
15561 unsigned char nc = m_str[idx + n];
15562 valid &= ((nc & 0xC0) == 0x80);
15563 value = (value << 6) | (nc & 0x3F);
15564 }
15565
15566 if (
15567 // Wrong bit pattern of following bytes
15568 (!valid) ||
15569 // Overlong encodings
15570 (value < 0x80) ||
15571 (0x80 <= value && value < 0x800 && encBytes > 2) ||
15572 (0x800 < value && value < 0x10000 && encBytes > 3) ||
15573 // Encoded value out of range
15574 (value >= 0x110000)
15575 ) {
15576 hexEscapeChar(os, c);
15577 break;
15578 }
15579
15580 // If we got here, this is in fact a valid(ish) utf-8 sequence
15581 for (std::size_t n = 0; n < encBytes; ++n) {
15582 os << m_str[idx + n];
15583 }
15584 idx += encBytes - 1;
15585 break;
15586 }
15587 }
15588 }
15589
15590 std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
15591 xmlEncode.encodeTo( os );
15592 return os;
15593 }
15594
15595 XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
15596 : m_writer( writer ),
15597 m_fmt(fmt)
15598 {}
15599
15600 XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
15601 : m_writer( other.m_writer ),
15602 m_fmt(other.m_fmt)
15603 {
15604 other.m_writer = nullptr;
15605 other.m_fmt = XmlFormatting::None;
15606 }
15607 XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
15608 if ( m_writer ) {
15609 m_writer->endElement();
15610 }
15611 m_writer = other.m_writer;
15612 other.m_writer = nullptr;
15613 m_fmt = other.m_fmt;
15614 other.m_fmt = XmlFormatting::None;
15615 return *this;
15616 }
15617
15618 XmlWriter::ScopedElement::~ScopedElement() {
15619 if (m_writer) {
15620 m_writer->endElement(m_fmt);
15621 }
15622 }
15623
15624 XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
15625 m_writer->writeText( text, fmt );
15626 return *this;
15627 }
15628
15629 XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
15630 {
15631 writeDeclaration();
15632 }
15633
15634 XmlWriter::~XmlWriter() {
15635 while (!m_tags.empty()) {
15636 endElement();
15637 }
15638 newlineIfNecessary();
15639 }
15640
15641 XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
15642 ensureTagClosed();
15643 newlineIfNecessary();
15644 if (shouldIndent(fmt)) {
15645 m_os << m_indent;
15646 m_indent += " ";
15647 }
15648 m_os << '<' << name;
15649 m_tags.push_back( name );
15650 m_tagIsOpen = true;
15651 applyFormatting(fmt);
15652 return *this;
15653 }
15654
15655 XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
15656 ScopedElement scoped( this, fmt );
15657 startElement( name, fmt );
15658 return scoped;
15659 }
15660
15661 XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
15662 m_indent = m_indent.substr(0, m_indent.size() - 2);
15663
15664 if( m_tagIsOpen ) {
15665 m_os << "/>";
15666 m_tagIsOpen = false;
15667 } else {
15668 newlineIfNecessary();
15669 if (shouldIndent(fmt)) {
15670 m_os << m_indent;
15671 }
15672 m_os << "</" << m_tags.back() << ">";
15673 }
15674 m_os << std::flush;
15675 applyFormatting(fmt);
15676 m_tags.pop_back();
15677 return *this;
15678 }
15679
15680 XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
15681 if( !name.empty() && !attribute.empty() )
15682 m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
15683 return *this;
15684 }
15685
15686 XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
15687 m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
15688 return *this;
15689 }
15690
15691 XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
15692 if( !text.empty() ){
15693 bool tagWasOpen = m_tagIsOpen;
15694 ensureTagClosed();
15695 if (tagWasOpen && shouldIndent(fmt)) {
15696 m_os << m_indent;
15697 }
15698 m_os << XmlEncode( text );
15699 applyFormatting(fmt);
15700 }
15701 return *this;
15702 }
15703
15704 XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
15705 ensureTagClosed();
15706 if (shouldIndent(fmt)) {
15707 m_os << m_indent;
15708 }
15709 m_os << "<!--" << text << "-->";
15710 applyFormatting(fmt);
15711 return *this;
15712 }
15713
15714 void XmlWriter::writeStylesheetRef( std::string const& url ) {
15715 m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
15716 }
15717
15718 XmlWriter& XmlWriter::writeBlankLine() {
15719 ensureTagClosed();
15720 m_os << '\n';
15721 return *this;
15722 }
15723
15724 void XmlWriter::ensureTagClosed() {
15725 if( m_tagIsOpen ) {
15726 m_os << '>' << std::flush;
15727 newlineIfNecessary();
15728 m_tagIsOpen = false;
15729 }
15730 }
15731
15732 void XmlWriter::applyFormatting(XmlFormatting fmt) {
15733 m_needsNewline = shouldNewline(fmt);
15734 }
15735
15736 void XmlWriter::writeDeclaration() {
15737 m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
15738 }
15739
15740 void XmlWriter::newlineIfNecessary() {
15741 if( m_needsNewline ) {
15742 m_os << std::endl;
15743 m_needsNewline = false;
15744 }
15745 }
15746 }
15747 // end catch_xmlwriter.cpp
15748 // start catch_reporter_bases.cpp
15749
15750 #include <cstring>
15751 #include <cfloat>
15752 #include <cstdio>
15753 #include <cassert>
15754 #include <memory>
15755
15756 namespace Catch {
15757 void prepareExpandedExpression(AssertionResult& result) {
15758 result.getExpandedExpression();
15759 }
15760
15761 // Because formatting using c++ streams is stateful, drop down to C is required
15762 // Alternatively we could use stringstream, but its performance is... not good.
15763 std::string getFormattedDuration( double duration ) {
15764 // Max exponent + 1 is required to represent the whole part
15765 // + 1 for decimal point
15766 // + 3 for the 3 decimal places
15767 // + 1 for null terminator
15768 const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
15769 char buffer[maxDoubleSize];
15770
15771 // Save previous errno, to prevent sprintf from overwriting it
15772 ErrnoGuard guard;
15773 #ifdef _MSC_VER
15774 sprintf_s(buffer, "%.3f", duration);
15775 #else
15776 std::sprintf(buffer, "%.3f", duration);
15777 #endif
15778 return std::string(buffer);
15779 }
15780
15781 bool shouldShowDuration( IConfig const& config, double duration ) {
15782 if ( config.showDurations() == ShowDurations::Always ) {
15783 return true;
15784 }
15785 if ( config.showDurations() == ShowDurations::Never ) {
15786 return false;
15787 }
15788 const double min = config.minDuration();
15789 return min >= 0 && duration >= min;
15790 }
15791
15792 std::string serializeFilters( std::vector<std::string> const& container ) {
15793 ReusableStringStream oss;
15794 bool first = true;
15795 for (auto&& filter : container)
15796 {
15797 if (!first)
15798 oss << ' ';
15799 else
15800 first = false;
15801
15802 oss << filter;
15803 }
15804 return oss.str();
15805 }
15806
15807 TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
15808 :StreamingReporterBase(_config) {}
15809
15810 std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
15811 return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
15812 }
15813
15814 void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
15815
15816 bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
15817 return false;
15818 }
15819
15820 } // end namespace Catch
15821 // end catch_reporter_bases.cpp
15822 // start catch_reporter_compact.cpp
15823
15824 namespace {
15825
15826 #ifdef CATCH_PLATFORM_MAC
15827 const char* failedString() { return "FAILED"; }
15828 const char* passedString() { return "PASSED"; }
15829 #else
15830 const char* failedString() { return "failed"; }
15831 const char* passedString() { return "passed"; }
15832 #endif
15833
15834 // Colour::LightGrey
15835 Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
15836
15837 std::string bothOrAll( std::size_t count ) {
15838 return count == 1 ? std::string() :
15839 count == 2 ? "both " : "all " ;
15840 }
15841
15842 } // anon namespace
15843
15844 namespace Catch {
15845 namespace {
15846 // Colour, message variants:
15847 // - white: No tests ran.
15848 // - red: Failed [both/all] N test cases, failed [both/all] M assertions.
15849 // - white: Passed [both/all] N test cases (no assertions).
15850 // - red: Failed N tests cases, failed M assertions.
15851 // - green: Passed [both/all] N tests cases with M assertions.
15852 void printTotals(std::ostream& out, const Totals& totals) {
15853 if (totals.testCases.total() == 0) {
15854 out << "No tests ran.";
15855 } else if (totals.testCases.failed == totals.testCases.total()) {
15856 Colour colour(Colour::ResultError);
15857 const std::string qualify_assertions_failed =
15858 totals.assertions.failed == totals.assertions.total() ?
15859 bothOrAll(totals.assertions.failed) : std::string();
15860 out <<
15861 "Failed " << bothOrAll(totals.testCases.failed)
15862 << pluralise(totals.testCases.failed, "test case") << ", "
15863 "failed " << qualify_assertions_failed <<
15864 pluralise(totals.assertions.failed, "assertion") << '.';
15865 } else if (totals.assertions.total() == 0) {
15866 out <<
15867 "Passed " << bothOrAll(totals.testCases.total())
15868 << pluralise(totals.testCases.total(), "test case")
15869 << " (no assertions).";
15870 } else if (totals.assertions.failed) {
15871 Colour colour(Colour::ResultError);
15872 out <<
15873 "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
15874 "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
15875 } else {
15876 Colour colour(Colour::ResultSuccess);
15877 out <<
15878 "Passed " << bothOrAll(totals.testCases.passed)
15879 << pluralise(totals.testCases.passed, "test case") <<
15880 " with " << pluralise(totals.assertions.passed, "assertion") << '.';
15881 }
15882 }
15883
15884 // Implementation of CompactReporter formatting
15885 class AssertionPrinter {
15886 public:
15887 AssertionPrinter& operator= (AssertionPrinter const&) = delete;
15888 AssertionPrinter(AssertionPrinter const&) = delete;
15889 AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
15890 : stream(_stream)
15891 , result(_stats.assertionResult)
15892 , messages(_stats.infoMessages)
15893 , itMessage(_stats.infoMessages.begin())
15894 , printInfoMessages(_printInfoMessages) {}
15895
15896 void print() {
15897 printSourceInfo();
15898
15899 itMessage = messages.begin();
15900
15901 switch (result.getResultType()) {
15902 case ResultWas::Ok:
15903 printResultType(Colour::ResultSuccess, passedString());
15904 printOriginalExpression();
15905 printReconstructedExpression();
15906 if (!result.hasExpression())
15907 printRemainingMessages(Colour::None);
15908 else
15909 printRemainingMessages();
15910 break;
15911 case ResultWas::ExpressionFailed:
15912 if (result.isOk())
15913 printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
15914 else
15915 printResultType(Colour::Error, failedString());
15916 printOriginalExpression();
15917 printReconstructedExpression();
15918 printRemainingMessages();
15919 break;
15920 case ResultWas::ThrewException:
15921 printResultType(Colour::Error, failedString());
15922 printIssue("unexpected exception with message:");
15923 printMessage();
15924 printExpressionWas();
15925 printRemainingMessages();
15926 break;
15927 case ResultWas::FatalErrorCondition:
15928 printResultType(Colour::Error, failedString());
15929 printIssue("fatal error condition with message:");
15930 printMessage();
15931 printExpressionWas();
15932 printRemainingMessages();
15933 break;
15934 case ResultWas::DidntThrowException:
15935 printResultType(Colour::Error, failedString());
15936 printIssue("expected exception, got none");
15937 printExpressionWas();
15938 printRemainingMessages();
15939 break;
15940 case ResultWas::Info:
15941 printResultType(Colour::None, "info");
15942 printMessage();
15943 printRemainingMessages();
15944 break;
15945 case ResultWas::Warning:
15946 printResultType(Colour::None, "warning");
15947 printMessage();
15948 printRemainingMessages();
15949 break;
15950 case ResultWas::ExplicitFailure:
15951 printResultType(Colour::Error, failedString());
15952 printIssue("explicitly");
15953 printRemainingMessages(Colour::None);
15954 break;
15955 // These cases are here to prevent compiler warnings
15956 case ResultWas::Unknown:
15957 case ResultWas::FailureBit:
15958 case ResultWas::Exception:
15959 printResultType(Colour::Error, "** internal error **");
15960 break;
15961 }
15962 }
15963
15964 private:
15965 void printSourceInfo() const {
15966 Colour colourGuard(Colour::FileName);
15967 stream << result.getSourceInfo() << ':';
15968 }
15969
15970 void printResultType(Colour::Code colour, std::string const& passOrFail) const {
15971 if (!passOrFail.empty()) {
15972 {
15973 Colour colourGuard(colour);
15974 stream << ' ' << passOrFail;
15975 }
15976 stream << ':';
15977 }
15978 }
15979
15980 void printIssue(std::string const& issue) const {
15981 stream << ' ' << issue;
15982 }
15983
15984 void printExpressionWas() {
15985 if (result.hasExpression()) {
15986 stream << ';';
15987 {
15988 Colour colour(dimColour());
15989 stream << " expression was:";
15990 }
15991 printOriginalExpression();
15992 }
15993 }
15994
15995 void printOriginalExpression() const {
15996 if (result.hasExpression()) {
15997 stream << ' ' << result.getExpression();
15998 }
15999 }
16000
16001 void printReconstructedExpression() const {
16002 if (result.hasExpandedExpression()) {
16003 {
16004 Colour colour(dimColour());
16005 stream << " for: ";
16006 }
16007 stream << result.getExpandedExpression();
16008 }
16009 }
16010
16011 void printMessage() {
16012 if (itMessage != messages.end()) {
16013 stream << " '" << itMessage->message << '\'';
16014 ++itMessage;
16015 }
16016 }
16017
16018 void printRemainingMessages(Colour::Code colour = dimColour()) {
16019 if (itMessage == messages.end())
16020 return;
16021
16022 const auto itEnd = messages.cend();
16023 const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
16024
16025 {
16026 Colour colourGuard(colour);
16027 stream << " with " << pluralise(N, "message") << ':';
16028 }
16029
16030 while (itMessage != itEnd) {
16031 // If this assertion is a warning ignore any INFO messages
16032 if (printInfoMessages || itMessage->type != ResultWas::Info) {
16033 printMessage();
16034 if (itMessage != itEnd) {
16035 Colour colourGuard(dimColour());
16036 stream << " and";
16037 }
16038 continue;
16039 }
16040 ++itMessage;
16041 }
16042 }
16043
16044 private:
16045 std::ostream& stream;
16046 AssertionResult const& result;
16047 std::vector<MessageInfo> messages;
16048 std::vector<MessageInfo>::const_iterator itMessage;
16049 bool printInfoMessages;
16050 };
16051
16052 } // anon namespace
16053
16054 std::string CompactReporter::getDescription() {
16055 return "Reports test results on a single line, suitable for IDEs";
16056 }
16057
16058 void CompactReporter::noMatchingTestCases( std::string const& spec ) {
16059 stream << "No test cases matched '" << spec << '\'' << std::endl;
16060 }
16061
16062 void CompactReporter::assertionStarting( AssertionInfo const& ) {}
16063
16064 bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
16065 AssertionResult const& result = _assertionStats.assertionResult;
16066
16067 bool printInfoMessages = true;
16068
16069 // Drop out if result was successful and we're not printing those
16070 if( !m_config->includeSuccessfulResults() && result.isOk() ) {
16071 if( result.getResultType() != ResultWas::Warning )
16072 return false;
16073 printInfoMessages = false;
16074 }
16075
16076 AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
16077 printer.print();
16078
16079 stream << std::endl;
16080 return true;
16081 }
16082
16083 void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
16084 double dur = _sectionStats.durationInSeconds;
16085 if ( shouldShowDuration( *m_config, dur ) ) {
16086 stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << std::endl;
16087 }
16088 }
16089
16090 void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
16091 printTotals( stream, _testRunStats.totals );
16092 stream << '\n' << std::endl;
16093 StreamingReporterBase::testRunEnded( _testRunStats );
16094 }
16095
16096 CompactReporter::~CompactReporter() {}
16097
16098 CATCH_REGISTER_REPORTER( "compact", CompactReporter )
16099
16100 } // end namespace Catch
16101 // end catch_reporter_compact.cpp
16102 // start catch_reporter_console.cpp
16103
16104 #include <cfloat>
16105 #include <cstdio>
16106
16107 #if defined(_MSC_VER)
16108 #pragma warning(push)
16109 #pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
16110 // Note that 4062 (not all labels are handled and default is missing) is enabled
16111 #endif
16112
16113 #if defined(__clang__)
16114 # pragma clang diagnostic push
16115 // For simplicity, benchmarking-only helpers are always enabled
16116 # pragma clang diagnostic ignored "-Wunused-function"
16117 #endif
16118
16119 namespace Catch {
16120
16121 namespace {
16122
16123 // Formatter impl for ConsoleReporter
16124 class ConsoleAssertionPrinter {
16125 public:
16126 ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
16127 ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
16128 ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
16129 : stream(_stream),
16130 stats(_stats),
16131 result(_stats.assertionResult),
16132 colour(Colour::None),
16133 message(result.getMessage()),
16134 messages(_stats.infoMessages),
16135 printInfoMessages(_printInfoMessages) {
16136 switch (result.getResultType()) {
16137 case ResultWas::Ok:
16138 colour = Colour::Success;
16139 passOrFail = "PASSED";
16140 //if( result.hasMessage() )
16141 if (_stats.infoMessages.size() == 1)
16142 messageLabel = "with message";
16143 if (_stats.infoMessages.size() > 1)
16144 messageLabel = "with messages";
16145 break;
16146 case ResultWas::ExpressionFailed:
16147 if (result.isOk()) {
16148 colour = Colour::Success;
16149 passOrFail = "FAILED - but was ok";
16150 } else {
16151 colour = Colour::Error;
16152 passOrFail = "FAILED";
16153 }
16154 if (_stats.infoMessages.size() == 1)
16155 messageLabel = "with message";
16156 if (_stats.infoMessages.size() > 1)
16157 messageLabel = "with messages";
16158 break;
16159 case ResultWas::ThrewException:
16160 colour = Colour::Error;
16161 passOrFail = "FAILED";
16162 messageLabel = "due to unexpected exception with ";
16163 if (_stats.infoMessages.size() == 1)
16164 messageLabel += "message";
16165 if (_stats.infoMessages.size() > 1)
16166 messageLabel += "messages";
16167 break;
16168 case ResultWas::FatalErrorCondition:
16169 colour = Colour::Error;
16170 passOrFail = "FAILED";
16171 messageLabel = "due to a fatal error condition";
16172 break;
16173 case ResultWas::DidntThrowException:
16174 colour = Colour::Error;
16175 passOrFail = "FAILED";
16176 messageLabel = "because no exception was thrown where one was expected";
16177 break;
16178 case ResultWas::Info:
16179 messageLabel = "info";
16180 break;
16181 case ResultWas::Warning:
16182 messageLabel = "warning";
16183 break;
16184 case ResultWas::ExplicitFailure:
16185 passOrFail = "FAILED";
16186 colour = Colour::Error;
16187 if (_stats.infoMessages.size() == 1)
16188 messageLabel = "explicitly with message";
16189 if (_stats.infoMessages.size() > 1)
16190 messageLabel = "explicitly with messages";
16191 break;
16192 // These cases are here to prevent compiler warnings
16193 case ResultWas::Unknown:
16194 case ResultWas::FailureBit:
16195 case ResultWas::Exception:
16196 passOrFail = "** internal error **";
16197 colour = Colour::Error;
16198 break;
16199 }
16200 }
16201
16202 void print() const {
16203 printSourceInfo();
16204 if (stats.totals.assertions.total() > 0) {
16205 printResultType();
16206 printOriginalExpression();
16207 printReconstructedExpression();
16208 } else {
16209 stream << '\n';
16210 }
16211 printMessage();
16212 }
16213
16214 private:
16215 void printResultType() const {
16216 if (!passOrFail.empty()) {
16217 Colour colourGuard(colour);
16218 stream << passOrFail << ":\n";
16219 }
16220 }
16221 void printOriginalExpression() const {
16222 if (result.hasExpression()) {
16223 Colour colourGuard(Colour::OriginalExpression);
16224 stream << " ";
16225 stream << result.getExpressionInMacro();
16226 stream << '\n';
16227 }
16228 }
16229 void printReconstructedExpression() const {
16230 if (result.hasExpandedExpression()) {
16231 stream << "with expansion:\n";
16232 Colour colourGuard(Colour::ReconstructedExpression);
16233 stream << Column(result.getExpandedExpression()).indent(2) << '\n';
16234 }
16235 }
16236 void printMessage() const {
16237 if (!messageLabel.empty())
16238 stream << messageLabel << ':' << '\n';
16239 for (auto const& msg : messages) {
16240 // If this assertion is a warning ignore any INFO messages
16241 if (printInfoMessages || msg.type != ResultWas::Info)
16242 stream << Column(msg.message).indent(2) << '\n';
16243 }
16244 }
16245 void printSourceInfo() const {
16246 Colour colourGuard(Colour::FileName);
16247 stream << result.getSourceInfo() << ": ";
16248 }
16249
16250 std::ostream& stream;
16251 AssertionStats const& stats;
16252 AssertionResult const& result;
16253 Colour::Code colour;
16254 std::string passOrFail;
16255 std::string messageLabel;
16256 std::string message;
16257 std::vector<MessageInfo> messages;
16258 bool printInfoMessages;
16259 };
16260
16261 std::size_t makeRatio(std::size_t number, std::size_t total) {
16262 std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
16263 return (ratio == 0 && number > 0) ? 1 : ratio;
16264 }
16265
16266 std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
16267 if (i > j && i > k)
16268 return i;
16269 else if (j > k)
16270 return j;
16271 else
16272 return k;
16273 }
16274
16275 struct ColumnInfo {
16276 enum Justification { Left, Right };
16277 std::string name;
16278 int width;
16279 Justification justification;
16280 };
16281 struct ColumnBreak {};
16282 struct RowBreak {};
16283
16284 class Duration {
16285 enum class Unit {
16286 Auto,
16287 Nanoseconds,
16288 Microseconds,
16289 Milliseconds,
16290 Seconds,
16291 Minutes
16292 };
16293 static const uint64_t s_nanosecondsInAMicrosecond = 1000;
16294 static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
16295 static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
16296 static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
16297
16298 double m_inNanoseconds;
16299 Unit m_units;
16300
16301 public:
16302 explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
16303 : m_inNanoseconds(inNanoseconds),
16304 m_units(units) {
16305 if (m_units == Unit::Auto) {
16306 if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
16307 m_units = Unit::Nanoseconds;
16308 else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
16309 m_units = Unit::Microseconds;
16310 else if (m_inNanoseconds < s_nanosecondsInASecond)
16311 m_units = Unit::Milliseconds;
16312 else if (m_inNanoseconds < s_nanosecondsInAMinute)
16313 m_units = Unit::Seconds;
16314 else
16315 m_units = Unit::Minutes;
16316 }
16317
16318 }
16319
16320 auto value() const -> double {
16321 switch (m_units) {
16322 case Unit::Microseconds:
16323 return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
16324 case Unit::Milliseconds:
16325 return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
16326 case Unit::Seconds:
16327 return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
16328 case Unit::Minutes:
16329 return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
16330 default:
16331 return m_inNanoseconds;
16332 }
16333 }
16334 auto unitsAsString() const -> std::string {
16335 switch (m_units) {
16336 case Unit::Nanoseconds:
16337 return "ns";
16338 case Unit::Microseconds:
16339 return "us";
16340 case Unit::Milliseconds:
16341 return "ms";
16342 case Unit::Seconds:
16343 return "s";
16344 case Unit::Minutes:
16345 return "m";
16346 default:
16347 return "** internal error **";
16348 }
16349
16350 }
16351 friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
16352 return os << duration.value() << ' ' << duration.unitsAsString();
16353 }
16354 };
16355 } // end anon namespace
16356
16357 class TablePrinter {
16358 std::ostream& m_os;
16359 std::vector<ColumnInfo> m_columnInfos;
16360 std::ostringstream m_oss;
16361 int m_currentColumn = -1;
16362 bool m_isOpen = false;
16363
16364 public:
16365 TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
16366 : m_os( os ),
16367 m_columnInfos( std::move( columnInfos ) ) {}
16368
16369 auto columnInfos() const -> std::vector<ColumnInfo> const& {
16370 return m_columnInfos;
16371 }
16372
16373 void open() {
16374 if (!m_isOpen) {
16375 m_isOpen = true;
16376 *this << RowBreak();
16377
16378 Columns headerCols;
16379 Spacer spacer(2);
16380 for (auto const& info : m_columnInfos) {
16381 headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
16382 headerCols += spacer;
16383 }
16384 m_os << headerCols << '\n';
16385
16386 m_os << Catch::getLineOfChars<'-'>() << '\n';
16387 }
16388 }
16389 void close() {
16390 if (m_isOpen) {
16391 *this << RowBreak();
16392 m_os << std::endl;
16393 m_isOpen = false;
16394 }
16395 }
16396
16397 template<typename T>
16398 friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
16399 tp.m_oss << value;
16400 return tp;
16401 }
16402
16403 friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
16404 auto colStr = tp.m_oss.str();
16405 const auto strSize = colStr.size();
16406 tp.m_oss.str("");
16407 tp.open();
16408 if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
16409 tp.m_currentColumn = -1;
16410 tp.m_os << '\n';
16411 }
16412 tp.m_currentColumn++;
16413
16414 auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
16415 auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
16416 ? std::string(colInfo.width - (strSize + 1), ' ')
16417 : std::string();
16418 if (colInfo.justification == ColumnInfo::Left)
16419 tp.m_os << colStr << padding << ' ';
16420 else
16421 tp.m_os << padding << colStr << ' ';
16422 return tp;
16423 }
16424
16425 friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
16426 if (tp.m_currentColumn > 0) {
16427 tp.m_os << '\n';
16428 tp.m_currentColumn = -1;
16429 }
16430 return tp;
16431 }
16432 };
16433
16434 ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
16435 : StreamingReporterBase(config),
16436 m_tablePrinter(new TablePrinter(config.stream(),
16437 [&config]() -> std::vector<ColumnInfo> {
16438 if (config.fullConfig()->benchmarkNoAnalysis())
16439 {
16440 return{
16441 { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
16442 { " samples", 14, ColumnInfo::Right },
16443 { " iterations", 14, ColumnInfo::Right },
16444 { " mean", 14, ColumnInfo::Right }
16445 };
16446 }
16447 else
16448 {
16449 return{
16450 { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
16451 { "samples mean std dev", 14, ColumnInfo::Right },
16452 { "iterations low mean low std dev", 14, ColumnInfo::Right },
16453 { "estimated high mean high std dev", 14, ColumnInfo::Right }
16454 };
16455 }
16456 }())) {}
16457 ConsoleReporter::~ConsoleReporter() = default;
16458
16459 std::string ConsoleReporter::getDescription() {
16460 return "Reports test results as plain lines of text";
16461 }
16462
16463 void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
16464 stream << "No test cases matched '" << spec << '\'' << std::endl;
16465 }
16466
16467 void ConsoleReporter::reportInvalidArguments(std::string const&arg){
16468 stream << "Invalid Filter: " << arg << std::endl;
16469 }
16470
16471 void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
16472
16473 bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
16474 AssertionResult const& result = _assertionStats.assertionResult;
16475
16476 bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
16477
16478 // Drop out if result was successful but we're not printing them.
16479 if (!includeResults && result.getResultType() != ResultWas::Warning)
16480 return false;
16481
16482 lazyPrint();
16483
16484 ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
16485 printer.print();
16486 stream << std::endl;
16487 return true;
16488 }
16489
16490 void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
16491 m_tablePrinter->close();
16492 m_headerPrinted = false;
16493 StreamingReporterBase::sectionStarting(_sectionInfo);
16494 }
16495 void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
16496 m_tablePrinter->close();
16497 if (_sectionStats.missingAssertions) {
16498 lazyPrint();
16499 Colour colour(Colour::ResultError);
16500 if (m_sectionStack.size() > 1)
16501 stream << "\nNo assertions in section";
16502 else
16503 stream << "\nNo assertions in test case";
16504 stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
16505 }
16506 double dur = _sectionStats.durationInSeconds;
16507 if (shouldShowDuration(*m_config, dur)) {
16508 stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << std::endl;
16509 }
16510 if (m_headerPrinted) {
16511 m_headerPrinted = false;
16512 }
16513 StreamingReporterBase::sectionEnded(_sectionStats);
16514 }
16515
16516 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
16517 void ConsoleReporter::benchmarkPreparing(std::string const& name) {
16518 lazyPrintWithoutClosingBenchmarkTable();
16519
16520 auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
16521
16522 bool firstLine = true;
16523 for (auto line : nameCol) {
16524 if (!firstLine)
16525 (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
16526 else
16527 firstLine = false;
16528
16529 (*m_tablePrinter) << line << ColumnBreak();
16530 }
16531 }
16532
16533 void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
16534 (*m_tablePrinter) << info.samples << ColumnBreak()
16535 << info.iterations << ColumnBreak();
16536 if (!m_config->benchmarkNoAnalysis())
16537 (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
16538 }
16539 void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
16540 if (m_config->benchmarkNoAnalysis())
16541 {
16542 (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
16543 }
16544 else
16545 {
16546 (*m_tablePrinter) << ColumnBreak()
16547 << Duration(stats.mean.point.count()) << ColumnBreak()
16548 << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
16549 << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
16550 << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
16551 << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
16552 << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
16553 }
16554 }
16555
16556 void ConsoleReporter::benchmarkFailed(std::string const& error) {
16557 Colour colour(Colour::Red);
16558 (*m_tablePrinter)
16559 << "Benchmark failed (" << error << ')'
16560 << ColumnBreak() << RowBreak();
16561 }
16562 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
16563
16564 void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
16565 m_tablePrinter->close();
16566 StreamingReporterBase::testCaseEnded(_testCaseStats);
16567 m_headerPrinted = false;
16568 }
16569 void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
16570 if (currentGroupInfo.used) {
16571 printSummaryDivider();
16572 stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
16573 printTotals(_testGroupStats.totals);
16574 stream << '\n' << std::endl;
16575 }
16576 StreamingReporterBase::testGroupEnded(_testGroupStats);
16577 }
16578 void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
16579 printTotalsDivider(_testRunStats.totals);
16580 printTotals(_testRunStats.totals);
16581 stream << std::endl;
16582 StreamingReporterBase::testRunEnded(_testRunStats);
16583 }
16584 void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
16585 StreamingReporterBase::testRunStarting(_testInfo);
16586 printTestFilters();
16587 }
16588
16589 void ConsoleReporter::lazyPrint() {
16590
16591 m_tablePrinter->close();
16592 lazyPrintWithoutClosingBenchmarkTable();
16593 }
16594
16595 void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
16596
16597 if (!currentTestRunInfo.used)
16598 lazyPrintRunInfo();
16599 if (!currentGroupInfo.used)
16600 lazyPrintGroupInfo();
16601
16602 if (!m_headerPrinted) {
16603 printTestCaseAndSectionHeader();
16604 m_headerPrinted = true;
16605 }
16606 }
16607 void ConsoleReporter::lazyPrintRunInfo() {
16608 stream << '\n' << getLineOfChars<'~'>() << '\n';
16609 Colour colour(Colour::SecondaryText);
16610 stream << currentTestRunInfo->name
16611 << " is a Catch v" << libraryVersion() << " host application.\n"
16612 << "Run with -? for options\n\n";
16613
16614 if (m_config->rngSeed() != 0)
16615 stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
16616
16617 currentTestRunInfo.used = true;
16618 }
16619 void ConsoleReporter::lazyPrintGroupInfo() {
16620 if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
16621 printClosedHeader("Group: " + currentGroupInfo->name);
16622 currentGroupInfo.used = true;
16623 }
16624 }
16625 void ConsoleReporter::printTestCaseAndSectionHeader() {
16626 assert(!m_sectionStack.empty());
16627 printOpenHeader(currentTestCaseInfo->name);
16628
16629 if (m_sectionStack.size() > 1) {
16630 Colour colourGuard(Colour::Headers);
16631
16632 auto
16633 it = m_sectionStack.begin() + 1, // Skip first section (test case)
16634 itEnd = m_sectionStack.end();
16635 for (; it != itEnd; ++it)
16636 printHeaderString(it->name, 2);
16637 }
16638
16639 SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
16640
16641 stream << getLineOfChars<'-'>() << '\n';
16642 Colour colourGuard(Colour::FileName);
16643 stream << lineInfo << '\n';
16644 stream << getLineOfChars<'.'>() << '\n' << std::endl;
16645 }
16646
16647 void ConsoleReporter::printClosedHeader(std::string const& _name) {
16648 printOpenHeader(_name);
16649 stream << getLineOfChars<'.'>() << '\n';
16650 }
16651 void ConsoleReporter::printOpenHeader(std::string const& _name) {
16652 stream << getLineOfChars<'-'>() << '\n';
16653 {
16654 Colour colourGuard(Colour::Headers);
16655 printHeaderString(_name);
16656 }
16657 }
16658
16659 // if string has a : in first line will set indent to follow it on
16660 // subsequent lines
16661 void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
16662 std::size_t i = _string.find(": ");
16663 if (i != std::string::npos)
16664 i += 2;
16665 else
16666 i = 0;
16667 stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
16668 }
16669
16670 struct SummaryColumn {
16671
16672 SummaryColumn( std::string _label, Colour::Code _colour )
16673 : label( std::move( _label ) ),
16674 colour( _colour ) {}
16675 SummaryColumn addRow( std::size_t count ) {
16676 ReusableStringStream rss;
16677 rss << count;
16678 std::string row = rss.str();
16679 for (auto& oldRow : rows) {
16680 while (oldRow.size() < row.size())
16681 oldRow = ' ' + oldRow;
16682 while (oldRow.size() > row.size())
16683 row = ' ' + row;
16684 }
16685 rows.push_back(row);
16686 return *this;
16687 }
16688
16689 std::string label;
16690 Colour::Code colour;
16691 std::vector<std::string> rows;
16692
16693 };
16694
16695 void ConsoleReporter::printTotals( Totals const& totals ) {
16696 if (totals.testCases.total() == 0) {
16697 stream << Colour(Colour::Warning) << "No tests ran\n";
16698 } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
16699 stream << Colour(Colour::ResultSuccess) << "All tests passed";
16700 stream << " ("
16701 << pluralise(totals.assertions.passed, "assertion") << " in "
16702 << pluralise(totals.testCases.passed, "test case") << ')'
16703 << '\n';
16704 } else {
16705
16706 std::vector<SummaryColumn> columns;
16707 columns.push_back(SummaryColumn("", Colour::None)
16708 .addRow(totals.testCases.total())
16709 .addRow(totals.assertions.total()));
16710 columns.push_back(SummaryColumn("passed", Colour::Success)
16711 .addRow(totals.testCases.passed)
16712 .addRow(totals.assertions.passed));
16713 columns.push_back(SummaryColumn("failed", Colour::ResultError)
16714 .addRow(totals.testCases.failed)
16715 .addRow(totals.assertions.failed));
16716 columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
16717 .addRow(totals.testCases.failedButOk)
16718 .addRow(totals.assertions.failedButOk));
16719
16720 printSummaryRow("test cases", columns, 0);
16721 printSummaryRow("assertions", columns, 1);
16722 }
16723 }
16724 void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
16725 for (auto col : cols) {
16726 std::string value = col.rows[row];
16727 if (col.label.empty()) {
16728 stream << label << ": ";
16729 if (value != "0")
16730 stream << value;
16731 else
16732 stream << Colour(Colour::Warning) << "- none -";
16733 } else if (value != "0") {
16734 stream << Colour(Colour::LightGrey) << " | ";
16735 stream << Colour(col.colour)
16736 << value << ' ' << col.label;
16737 }
16738 }
16739 stream << '\n';
16740 }
16741
16742 void ConsoleReporter::printTotalsDivider(Totals const& totals) {
16743 if (totals.testCases.total() > 0) {
16744 std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
16745 std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
16746 std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
16747 while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
16748 findMax(failedRatio, failedButOkRatio, passedRatio)++;
16749 while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
16750 findMax(failedRatio, failedButOkRatio, passedRatio)--;
16751
16752 stream << Colour(Colour::Error) << std::string(failedRatio, '=');
16753 stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
16754 if (totals.testCases.allPassed())
16755 stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
16756 else
16757 stream << Colour(Colour::Success) << std::string(passedRatio, '=');
16758 } else {
16759 stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
16760 }
16761 stream << '\n';
16762 }
16763 void ConsoleReporter::printSummaryDivider() {
16764 stream << getLineOfChars<'-'>() << '\n';
16765 }
16766
16767 void ConsoleReporter::printTestFilters() {
16768 if (m_config->testSpec().hasFilters()) {
16769 Colour guard(Colour::BrightYellow);
16770 stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
16771 }
16772 }
16773
16774 CATCH_REGISTER_REPORTER("console", ConsoleReporter)
16775
16776 } // end namespace Catch
16777
16778 #if defined(_MSC_VER)
16779 #pragma warning(pop)
16780 #endif
16781
16782 #if defined(__clang__)
16783 # pragma clang diagnostic pop
16784 #endif
16785 // end catch_reporter_console.cpp
16786 // start catch_reporter_junit.cpp
16787
16788 #include <cassert>
16789 #include <sstream>
16790 #include <ctime>
16791 #include <algorithm>
16792
16793 namespace Catch {
16794
16795 namespace {
16796 std::string getCurrentTimestamp() {
16797 // Beware, this is not reentrant because of backward compatibility issues
16798 // Also, UTC only, again because of backward compatibility (%z is C++11)
16799 time_t rawtime;
16800 std::time(&rawtime);
16801 auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
16802
16803 #ifdef _MSC_VER
16804 std::tm timeInfo = {};
16805 gmtime_s(&timeInfo, &rawtime);
16806 #else
16807 std::tm* timeInfo;
16808 timeInfo = std::gmtime(&rawtime);
16809 #endif
16810
16811 char timeStamp[timeStampSize];
16812 const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
16813
16814 #ifdef _MSC_VER
16815 std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
16816 #else
16817 std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
16818 #endif
16819 return std::string(timeStamp);
16820 }
16821
16822 std::string fileNameTag(const std::vector<std::string> &tags) {
16823 auto it = std::find_if(begin(tags),
16824 end(tags),
16825 [] (std::string const& tag) {return tag.front() == '#'; });
16826 if (it != tags.end())
16827 return it->substr(1);
16828 return std::string();
16829 }
16830 } // anonymous namespace
16831
16832 JunitReporter::JunitReporter( ReporterConfig const& _config )
16833 : CumulativeReporterBase( _config ),
16834 xml( _config.stream() )
16835 {
16836 m_reporterPrefs.shouldRedirectStdOut = true;
16837 m_reporterPrefs.shouldReportAllAssertions = true;
16838 }
16839
16840 JunitReporter::~JunitReporter() {}
16841
16842 std::string JunitReporter::getDescription() {
16843 return "Reports test results in an XML format that looks like Ant's junitreport target";
16844 }
16845
16846 void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
16847
16848 void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) {
16849 CumulativeReporterBase::testRunStarting( runInfo );
16850 xml.startElement( "testsuites" );
16851 }
16852
16853 void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
16854 suiteTimer.start();
16855 stdOutForSuite.clear();
16856 stdErrForSuite.clear();
16857 unexpectedExceptions = 0;
16858 CumulativeReporterBase::testGroupStarting( groupInfo );
16859 }
16860
16861 void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
16862 m_okToFail = testCaseInfo.okToFail();
16863 }
16864
16865 bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
16866 if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
16867 unexpectedExceptions++;
16868 return CumulativeReporterBase::assertionEnded( assertionStats );
16869 }
16870
16871 void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
16872 stdOutForSuite += testCaseStats.stdOut;
16873 stdErrForSuite += testCaseStats.stdErr;
16874 CumulativeReporterBase::testCaseEnded( testCaseStats );
16875 }
16876
16877 void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
16878 double suiteTime = suiteTimer.getElapsedSeconds();
16879 CumulativeReporterBase::testGroupEnded( testGroupStats );
16880 writeGroup( *m_testGroups.back(), suiteTime );
16881 }
16882
16883 void JunitReporter::testRunEndedCumulative() {
16884 xml.endElement();
16885 }
16886
16887 void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
16888 XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
16889
16890 TestGroupStats const& stats = groupNode.value;
16891 xml.writeAttribute( "name", stats.groupInfo.name );
16892 xml.writeAttribute( "errors", unexpectedExceptions );
16893 xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
16894 xml.writeAttribute( "tests", stats.totals.assertions.total() );
16895 xml.writeAttribute( "hostname", "tbd" ); // !TBD
16896 if( m_config->showDurations() == ShowDurations::Never )
16897 xml.writeAttribute( "time", "" );
16898 else
16899 xml.writeAttribute( "time", suiteTime );
16900 xml.writeAttribute( "timestamp", getCurrentTimestamp() );
16901
16902 // Write properties if there are any
16903 if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
16904 auto properties = xml.scopedElement("properties");
16905 if (m_config->hasTestFilters()) {
16906 xml.scopedElement("property")
16907 .writeAttribute("name", "filters")
16908 .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
16909 }
16910 if (m_config->rngSeed() != 0) {
16911 xml.scopedElement("property")
16912 .writeAttribute("name", "random-seed")
16913 .writeAttribute("value", m_config->rngSeed());
16914 }
16915 }
16916
16917 // Write test cases
16918 for( auto const& child : groupNode.children )
16919 writeTestCase( *child );
16920
16921 xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
16922 xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
16923 }
16924
16925 void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
16926 TestCaseStats const& stats = testCaseNode.value;
16927
16928 // All test cases have exactly one section - which represents the
16929 // test case itself. That section may have 0-n nested sections
16930 assert( testCaseNode.children.size() == 1 );
16931 SectionNode const& rootSection = *testCaseNode.children.front();
16932
16933 std::string className = stats.testInfo.className;
16934
16935 if( className.empty() ) {
16936 className = fileNameTag(stats.testInfo.tags);
16937 if ( className.empty() )
16938 className = "global";
16939 }
16940
16941 if ( !m_config->name().empty() )
16942 className = m_config->name() + "." + className;
16943
16944 writeSection( className, "", rootSection );
16945 }
16946
16947 void JunitReporter::writeSection( std::string const& className,
16948 std::string const& rootName,
16949 SectionNode const& sectionNode ) {
16950 std::string name = trim( sectionNode.stats.sectionInfo.name );
16951 if( !rootName.empty() )
16952 name = rootName + '/' + name;
16953
16954 if( !sectionNode.assertions.empty() ||
16955 !sectionNode.stdOut.empty() ||
16956 !sectionNode.stdErr.empty() ) {
16957 XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
16958 if( className.empty() ) {
16959 xml.writeAttribute( "classname", name );
16960 xml.writeAttribute( "name", "root" );
16961 }
16962 else {
16963 xml.writeAttribute( "classname", className );
16964 xml.writeAttribute( "name", name );
16965 }
16966 xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
16967 // This is not ideal, but it should be enough to mimic gtest's
16968 // junit output.
16969 // Ideally the JUnit reporter would also handle `skipTest`
16970 // events and write those out appropriately.
16971 xml.writeAttribute( "status", "run" );
16972
16973 writeAssertions( sectionNode );
16974
16975 if( !sectionNode.stdOut.empty() )
16976 xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
16977 if( !sectionNode.stdErr.empty() )
16978 xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
16979 }
16980 for( auto const& childNode : sectionNode.childSections )
16981 if( className.empty() )
16982 writeSection( name, "", *childNode );
16983 else
16984 writeSection( className, name, *childNode );
16985 }
16986
16987 void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
16988 for( auto const& assertion : sectionNode.assertions )
16989 writeAssertion( assertion );
16990 }
16991
16992 void JunitReporter::writeAssertion( AssertionStats const& stats ) {
16993 AssertionResult const& result = stats.assertionResult;
16994 if( !result.isOk() ) {
16995 std::string elementName;
16996 switch( result.getResultType() ) {
16997 case ResultWas::ThrewException:
16998 case ResultWas::FatalErrorCondition:
16999 elementName = "error";
17000 break;
17001 case ResultWas::ExplicitFailure:
17002 case ResultWas::ExpressionFailed:
17003 case ResultWas::DidntThrowException:
17004 elementName = "failure";
17005 break;
17006
17007 // We should never see these here:
17008 case ResultWas::Info:
17009 case ResultWas::Warning:
17010 case ResultWas::Ok:
17011 case ResultWas::Unknown:
17012 case ResultWas::FailureBit:
17013 case ResultWas::Exception:
17014 elementName = "internalError";
17015 break;
17016 }
17017
17018 XmlWriter::ScopedElement e = xml.scopedElement( elementName );
17019
17020 xml.writeAttribute( "message", result.getExpression() );
17021 xml.writeAttribute( "type", result.getTestMacroName() );
17022
17023 ReusableStringStream rss;
17024 if (stats.totals.assertions.total() > 0) {
17025 rss << "FAILED" << ":\n";
17026 if (result.hasExpression()) {
17027 rss << " ";
17028 rss << result.getExpressionInMacro();
17029 rss << '\n';
17030 }
17031 if (result.hasExpandedExpression()) {
17032 rss << "with expansion:\n";
17033 rss << Column(result.getExpandedExpression()).indent(2) << '\n';
17034 }
17035 } else {
17036 rss << '\n';
17037 }
17038
17039 if( !result.getMessage().empty() )
17040 rss << result.getMessage() << '\n';
17041 for( auto const& msg : stats.infoMessages )
17042 if( msg.type == ResultWas::Info )
17043 rss << msg.message << '\n';
17044
17045 rss << "at " << result.getSourceInfo();
17046 xml.writeText( rss.str(), XmlFormatting::Newline );
17047 }
17048 }
17049
17050 CATCH_REGISTER_REPORTER( "junit", JunitReporter )
17051
17052 } // end namespace Catch
17053 // end catch_reporter_junit.cpp
17054 // start catch_reporter_listening.cpp
17055
17056 #include <cassert>
17057
17058 namespace Catch {
17059
17060 ListeningReporter::ListeningReporter() {
17061 // We will assume that listeners will always want all assertions
17062 m_preferences.shouldReportAllAssertions = true;
17063 }
17064
17065 void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
17066 m_listeners.push_back( std::move( listener ) );
17067 }
17068
17069 void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
17070 assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
17071 m_reporter = std::move( reporter );
17072 m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
17073 }
17074
17075 ReporterPreferences ListeningReporter::getPreferences() const {
17076 return m_preferences;
17077 }
17078
17079 std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
17080 return std::set<Verbosity>{ };
17081 }
17082
17083 void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
17084 for ( auto const& listener : m_listeners ) {
17085 listener->noMatchingTestCases( spec );
17086 }
17087 m_reporter->noMatchingTestCases( spec );
17088 }
17089
17090 void ListeningReporter::reportInvalidArguments(std::string const&arg){
17091 for ( auto const& listener : m_listeners ) {
17092 listener->reportInvalidArguments( arg );
17093 }
17094 m_reporter->reportInvalidArguments( arg );
17095 }
17096
17097 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
17098 void ListeningReporter::benchmarkPreparing( std::string const& name ) {
17099 for (auto const& listener : m_listeners) {
17100 listener->benchmarkPreparing(name);
17101 }
17102 m_reporter->benchmarkPreparing(name);
17103 }
17104 void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
17105 for ( auto const& listener : m_listeners ) {
17106 listener->benchmarkStarting( benchmarkInfo );
17107 }
17108 m_reporter->benchmarkStarting( benchmarkInfo );
17109 }
17110 void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
17111 for ( auto const& listener : m_listeners ) {
17112 listener->benchmarkEnded( benchmarkStats );
17113 }
17114 m_reporter->benchmarkEnded( benchmarkStats );
17115 }
17116
17117 void ListeningReporter::benchmarkFailed( std::string const& error ) {
17118 for (auto const& listener : m_listeners) {
17119 listener->benchmarkFailed(error);
17120 }
17121 m_reporter->benchmarkFailed(error);
17122 }
17123 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
17124
17125 void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
17126 for ( auto const& listener : m_listeners ) {
17127 listener->testRunStarting( testRunInfo );
17128 }
17129 m_reporter->testRunStarting( testRunInfo );
17130 }
17131
17132 void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
17133 for ( auto const& listener : m_listeners ) {
17134 listener->testGroupStarting( groupInfo );
17135 }
17136 m_reporter->testGroupStarting( groupInfo );
17137 }
17138
17139 void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
17140 for ( auto const& listener : m_listeners ) {
17141 listener->testCaseStarting( testInfo );
17142 }
17143 m_reporter->testCaseStarting( testInfo );
17144 }
17145
17146 void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
17147 for ( auto const& listener : m_listeners ) {
17148 listener->sectionStarting( sectionInfo );
17149 }
17150 m_reporter->sectionStarting( sectionInfo );
17151 }
17152
17153 void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
17154 for ( auto const& listener : m_listeners ) {
17155 listener->assertionStarting( assertionInfo );
17156 }
17157 m_reporter->assertionStarting( assertionInfo );
17158 }
17159
17160 // The return value indicates if the messages buffer should be cleared:
17161 bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
17162 for( auto const& listener : m_listeners ) {
17163 static_cast<void>( listener->assertionEnded( assertionStats ) );
17164 }
17165 return m_reporter->assertionEnded( assertionStats );
17166 }
17167
17168 void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
17169 for ( auto const& listener : m_listeners ) {
17170 listener->sectionEnded( sectionStats );
17171 }
17172 m_reporter->sectionEnded( sectionStats );
17173 }
17174
17175 void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
17176 for ( auto const& listener : m_listeners ) {
17177 listener->testCaseEnded( testCaseStats );
17178 }
17179 m_reporter->testCaseEnded( testCaseStats );
17180 }
17181
17182 void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
17183 for ( auto const& listener : m_listeners ) {
17184 listener->testGroupEnded( testGroupStats );
17185 }
17186 m_reporter->testGroupEnded( testGroupStats );
17187 }
17188
17189 void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
17190 for ( auto const& listener : m_listeners ) {
17191 listener->testRunEnded( testRunStats );
17192 }
17193 m_reporter->testRunEnded( testRunStats );
17194 }
17195
17196 void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
17197 for ( auto const& listener : m_listeners ) {
17198 listener->skipTest( testInfo );
17199 }
17200 m_reporter->skipTest( testInfo );
17201 }
17202
17203 bool ListeningReporter::isMulti() const {
17204 return true;
17205 }
17206
17207 } // end namespace Catch
17208 // end catch_reporter_listening.cpp
17209 // start catch_reporter_xml.cpp
17210
17211 #if defined(_MSC_VER)
17212 #pragma warning(push)
17213 #pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
17214 // Note that 4062 (not all labels are handled
17215 // and default is missing) is enabled
17216 #endif
17217
17218 namespace Catch {
17219 XmlReporter::XmlReporter( ReporterConfig const& _config )
17220 : StreamingReporterBase( _config ),
17221 m_xml(_config.stream())
17222 {
17223 m_reporterPrefs.shouldRedirectStdOut = true;
17224 m_reporterPrefs.shouldReportAllAssertions = true;
17225 }
17226
17227 XmlReporter::~XmlReporter() = default;
17228
17229 std::string XmlReporter::getDescription() {
17230 return "Reports test results as an XML document";
17231 }
17232
17233 std::string XmlReporter::getStylesheetRef() const {
17234 return std::string();
17235 }
17236
17237 void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
17238 m_xml
17239 .writeAttribute( "filename", sourceInfo.file )
17240 .writeAttribute( "line", sourceInfo.line );
17241 }
17242
17243 void XmlReporter::noMatchingTestCases( std::string const& s ) {
17244 StreamingReporterBase::noMatchingTestCases( s );
17245 }
17246
17247 void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
17248 StreamingReporterBase::testRunStarting( testInfo );
17249 std::string stylesheetRef = getStylesheetRef();
17250 if( !stylesheetRef.empty() )
17251 m_xml.writeStylesheetRef( stylesheetRef );
17252 m_xml.startElement( "Catch" );
17253 if( !m_config->name().empty() )
17254 m_xml.writeAttribute( "name", m_config->name() );
17255 if (m_config->testSpec().hasFilters())
17256 m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
17257 if( m_config->rngSeed() != 0 )
17258 m_xml.scopedElement( "Randomness" )
17259 .writeAttribute( "seed", m_config->rngSeed() );
17260 }
17261
17262 void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
17263 StreamingReporterBase::testGroupStarting( groupInfo );
17264 m_xml.startElement( "Group" )
17265 .writeAttribute( "name", groupInfo.name );
17266 }
17267
17268 void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
17269 StreamingReporterBase::testCaseStarting(testInfo);
17270 m_xml.startElement( "TestCase" )
17271 .writeAttribute( "name", trim( testInfo.name ) )
17272 .writeAttribute( "description", testInfo.description )
17273 .writeAttribute( "tags", testInfo.tagsAsString() );
17274
17275 writeSourceInfo( testInfo.lineInfo );
17276
17277 if ( m_config->showDurations() == ShowDurations::Always )
17278 m_testCaseTimer.start();
17279 m_xml.ensureTagClosed();
17280 }
17281
17282 void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
17283 StreamingReporterBase::sectionStarting( sectionInfo );
17284 if( m_sectionDepth++ > 0 ) {
17285 m_xml.startElement( "Section" )
17286 .writeAttribute( "name", trim( sectionInfo.name ) );
17287 writeSourceInfo( sectionInfo.lineInfo );
17288 m_xml.ensureTagClosed();
17289 }
17290 }
17291
17292 void XmlReporter::assertionStarting( AssertionInfo const& ) { }
17293
17294 bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
17295
17296 AssertionResult const& result = assertionStats.assertionResult;
17297
17298 bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
17299
17300 if( includeResults || result.getResultType() == ResultWas::Warning ) {
17301 // Print any info messages in <Info> tags.
17302 for( auto const& msg : assertionStats.infoMessages ) {
17303 if( msg.type == ResultWas::Info && includeResults ) {
17304 m_xml.scopedElement( "Info" )
17305 .writeText( msg.message );
17306 } else if ( msg.type == ResultWas::Warning ) {
17307 m_xml.scopedElement( "Warning" )
17308 .writeText( msg.message );
17309 }
17310 }
17311 }
17312
17313 // Drop out if result was successful but we're not printing them.
17314 if( !includeResults && result.getResultType() != ResultWas::Warning )
17315 return true;
17316
17317 // Print the expression if there is one.
17318 if( result.hasExpression() ) {
17319 m_xml.startElement( "Expression" )
17320 .writeAttribute( "success", result.succeeded() )
17321 .writeAttribute( "type", result.getTestMacroName() );
17322
17323 writeSourceInfo( result.getSourceInfo() );
17324
17325 m_xml.scopedElement( "Original" )
17326 .writeText( result.getExpression() );
17327 m_xml.scopedElement( "Expanded" )
17328 .writeText( result.getExpandedExpression() );
17329 }
17330
17331 // And... Print a result applicable to each result type.
17332 switch( result.getResultType() ) {
17333 case ResultWas::ThrewException:
17334 m_xml.startElement( "Exception" );
17335 writeSourceInfo( result.getSourceInfo() );
17336 m_xml.writeText( result.getMessage() );
17337 m_xml.endElement();
17338 break;
17339 case ResultWas::FatalErrorCondition:
17340 m_xml.startElement( "FatalErrorCondition" );
17341 writeSourceInfo( result.getSourceInfo() );
17342 m_xml.writeText( result.getMessage() );
17343 m_xml.endElement();
17344 break;
17345 case ResultWas::Info:
17346 m_xml.scopedElement( "Info" )
17347 .writeText( result.getMessage() );
17348 break;
17349 case ResultWas::Warning:
17350 // Warning will already have been written
17351 break;
17352 case ResultWas::ExplicitFailure:
17353 m_xml.startElement( "Failure" );
17354 writeSourceInfo( result.getSourceInfo() );
17355 m_xml.writeText( result.getMessage() );
17356 m_xml.endElement();
17357 break;
17358 default:
17359 break;
17360 }
17361
17362 if( result.hasExpression() )
17363 m_xml.endElement();
17364
17365 return true;
17366 }
17367
17368 void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
17369 StreamingReporterBase::sectionEnded( sectionStats );
17370 if( --m_sectionDepth > 0 ) {
17371 XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
17372 e.writeAttribute( "successes", sectionStats.assertions.passed );
17373 e.writeAttribute( "failures", sectionStats.assertions.failed );
17374 e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
17375
17376 if ( m_config->showDurations() == ShowDurations::Always )
17377 e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
17378
17379 m_xml.endElement();
17380 }
17381 }
17382
17383 void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
17384 StreamingReporterBase::testCaseEnded( testCaseStats );
17385 XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
17386 e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
17387
17388 if ( m_config->showDurations() == ShowDurations::Always )
17389 e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
17390
17391 if( !testCaseStats.stdOut.empty() )
17392 m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
17393 if( !testCaseStats.stdErr.empty() )
17394 m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
17395
17396 m_xml.endElement();
17397 }
17398
17399 void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
17400 StreamingReporterBase::testGroupEnded( testGroupStats );
17401 // TODO: Check testGroupStats.aborting and act accordingly.
17402 m_xml.scopedElement( "OverallResults" )
17403 .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
17404 .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
17405 .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
17406 m_xml.scopedElement( "OverallResultsCases")
17407 .writeAttribute( "successes", testGroupStats.totals.testCases.passed )
17408 .writeAttribute( "failures", testGroupStats.totals.testCases.failed )
17409 .writeAttribute( "expectedFailures", testGroupStats.totals.testCases.failedButOk );
17410 m_xml.endElement();
17411 }
17412
17413 void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
17414 StreamingReporterBase::testRunEnded( testRunStats );
17415 m_xml.scopedElement( "OverallResults" )
17416 .writeAttribute( "successes", testRunStats.totals.assertions.passed )
17417 .writeAttribute( "failures", testRunStats.totals.assertions.failed )
17418 .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
17419 m_xml.scopedElement( "OverallResultsCases")
17420 .writeAttribute( "successes", testRunStats.totals.testCases.passed )
17421 .writeAttribute( "failures", testRunStats.totals.testCases.failed )
17422 .writeAttribute( "expectedFailures", testRunStats.totals.testCases.failedButOk );
17423 m_xml.endElement();
17424 }
17425
17426 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
17427 void XmlReporter::benchmarkPreparing(std::string const& name) {
17428 m_xml.startElement("BenchmarkResults")
17429 .writeAttribute("name", name);
17430 }
17431
17432 void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
17433 m_xml.writeAttribute("samples", info.samples)
17434 .writeAttribute("resamples", info.resamples)
17435 .writeAttribute("iterations", info.iterations)
17436 .writeAttribute("clockResolution", info.clockResolution)
17437 .writeAttribute("estimatedDuration", info.estimatedDuration)
17438 .writeComment("All values in nano seconds");
17439 }
17440
17441 void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
17442 m_xml.startElement("mean")
17443 .writeAttribute("value", benchmarkStats.mean.point.count())
17444 .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
17445 .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
17446 .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
17447 m_xml.endElement();
17448 m_xml.startElement("standardDeviation")
17449 .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
17450 .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
17451 .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
17452 .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
17453 m_xml.endElement();
17454 m_xml.startElement("outliers")
17455 .writeAttribute("variance", benchmarkStats.outlierVariance)
17456 .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
17457 .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
17458 .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
17459 .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
17460 m_xml.endElement();
17461 m_xml.endElement();
17462 }
17463
17464 void XmlReporter::benchmarkFailed(std::string const &error) {
17465 m_xml.scopedElement("failed").
17466 writeAttribute("message", error);
17467 m_xml.endElement();
17468 }
17469 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
17470
17471 CATCH_REGISTER_REPORTER( "xml", XmlReporter )
17472
17473 } // end namespace Catch
17474
17475 #if defined(_MSC_VER)
17476 #pragma warning(pop)
17477 #endif
17478 // end catch_reporter_xml.cpp
17479
17480 namespace Catch {
17481 LeakDetector leakDetector;
17482 }
17483
17484 #ifdef __clang__
17485 #pragma clang diagnostic pop
17486 #endif
17487
17488 // end catch_impl.hpp
17489 #endif
17490
17491 #ifdef CATCH_CONFIG_MAIN
17492 // start catch_default_main.hpp
17493
17494 #ifndef __OBJC__
17495
17496 #if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
17497 // Standard C/C++ Win32 Unicode wmain entry point
17498 extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
17499 #else
17500 // Standard C/C++ main entry point
17501 int main (int argc, char * argv[]) {
17502 #endif
17503
17504 return Catch::Session().run( argc, argv );
17505 }
17506
17507 #else // __OBJC__
17508
17509 // Objective-C entry point
17510 int main (int argc, char * const argv[]) {
17511 #if !CATCH_ARC_ENABLED
17512 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
17513 #endif
17514
17515 Catch::registerTestMethods();
17516 int result = Catch::Session().run( argc, (char**)argv );
17517
17518 #if !CATCH_ARC_ENABLED
17519 [pool drain];
17520 #endif
17521
17522 return result;
17523 }
17524
17525 #endif // __OBJC__
17526
17527 // end catch_default_main.hpp
17528 #endif
17529
17530 #if !defined(CATCH_CONFIG_IMPL_ONLY)
17531
17532 #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
17533 # undef CLARA_CONFIG_MAIN
17534 #endif
17535
17536 #if !defined(CATCH_CONFIG_DISABLE)
17537 //////
17538 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
17539 #ifdef CATCH_CONFIG_PREFIX_ALL
17540
17541 #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
17542 #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
17543
17544 #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
17545 #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
17546 #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
17547 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17548 #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
17549 #endif// CATCH_CONFIG_DISABLE_MATCHERS
17550 #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
17551
17552 #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17553 #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
17554 #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17555 #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17556 #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
17557
17558 #define CATCH_CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17559 #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
17560 #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
17561 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17562 #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
17563 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17564 #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17565
17566 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17567 #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
17568
17569 #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
17570 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17571
17572 #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
17573 #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
17574 #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
17575 #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
17576
17577 #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
17578 #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
17579 #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
17580 #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
17581 #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
17582 #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
17583 #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
17584 #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17585 #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17586
17587 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
17588
17589 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
17590 #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
17591 #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
17592 #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17593 #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
17594 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
17595 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
17596 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
17597 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
17598 #else
17599 #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
17600 #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
17601 #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
17602 #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
17603 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
17604 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
17605 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
17606 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
17607 #endif
17608
17609 #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
17610 #define CATCH_STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
17611 #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
17612 #else
17613 #define CATCH_STATIC_REQUIRE( ... ) CATCH_REQUIRE( __VA_ARGS__ )
17614 #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
17615 #endif
17616
17617 // "BDD-style" convenience wrappers
17618 #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
17619 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
17620 #define CATCH_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
17621 #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
17622 #define CATCH_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
17623 #define CATCH_AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
17624 #define CATCH_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
17625 #define CATCH_AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
17626
17627 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
17628 #define CATCH_BENCHMARK(...) \
17629 INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
17630 #define CATCH_BENCHMARK_ADVANCED(name) \
17631 INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
17632 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
17633
17634 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
17635 #else
17636
17637 #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
17638 #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
17639
17640 #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
17641 #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
17642 #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
17643 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17644 #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
17645 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17646 #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
17647
17648 #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17649 #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
17650 #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17651 #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17652 #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
17653
17654 #define CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17655 #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
17656 #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
17657 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17658 #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
17659 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17660 #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17661
17662 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17663 #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
17664
17665 #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
17666 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17667
17668 #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
17669 #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
17670 #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
17671 #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
17672
17673 #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
17674 #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
17675 #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
17676 #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
17677 #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
17678 #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
17679 #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
17680 #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17681 #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
17682 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
17683
17684 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
17685 #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
17686 #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
17687 #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17688 #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
17689 #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
17690 #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
17691 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
17692 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
17693 #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
17694 #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
17695 #else
17696 #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
17697 #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
17698 #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
17699 #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
17700 #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
17701 #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
17702 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
17703 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
17704 #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
17705 #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
17706 #endif
17707
17708 #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
17709 #define STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
17710 #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
17711 #else
17712 #define STATIC_REQUIRE( ... ) REQUIRE( __VA_ARGS__ )
17713 #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
17714 #endif
17715
17716 #endif
17717
17718 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
17719
17720 // "BDD-style" convenience wrappers
17721 #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
17722 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
17723
17724 #define GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
17725 #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
17726 #define WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
17727 #define AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
17728 #define THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
17729 #define AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
17730
17731 #if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
17732 #define BENCHMARK(...) \
17733 INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
17734 #define BENCHMARK_ADVANCED(name) \
17735 INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
17736 #endif // CATCH_CONFIG_ENABLE_BENCHMARKING
17737
17738 using Catch::Detail::Approx;
17739
17740 #else // CATCH_CONFIG_DISABLE
17741
17742 //////
17743 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
17744 #ifdef CATCH_CONFIG_PREFIX_ALL
17745
17746 #define CATCH_REQUIRE( ... ) (void)(0)
17747 #define CATCH_REQUIRE_FALSE( ... ) (void)(0)
17748
17749 #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
17750 #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
17751 #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
17752 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17753 #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
17754 #endif// CATCH_CONFIG_DISABLE_MATCHERS
17755 #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
17756
17757 #define CATCH_CHECK( ... ) (void)(0)
17758 #define CATCH_CHECK_FALSE( ... ) (void)(0)
17759 #define CATCH_CHECKED_IF( ... ) if (__VA_ARGS__)
17760 #define CATCH_CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
17761 #define CATCH_CHECK_NOFAIL( ... ) (void)(0)
17762
17763 #define CATCH_CHECK_THROWS( ... ) (void)(0)
17764 #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
17765 #define CATCH_CHECK_THROWS_WITH( expr, matcher ) (void)(0)
17766 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17767 #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
17768 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17769 #define CATCH_CHECK_NOTHROW( ... ) (void)(0)
17770
17771 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17772 #define CATCH_CHECK_THAT( arg, matcher ) (void)(0)
17773
17774 #define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
17775 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17776
17777 #define CATCH_INFO( msg ) (void)(0)
17778 #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
17779 #define CATCH_WARN( msg ) (void)(0)
17780 #define CATCH_CAPTURE( msg ) (void)(0)
17781
17782 #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
17783 #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
17784 #define CATCH_METHOD_AS_TEST_CASE( method, ... )
17785 #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
17786 #define CATCH_SECTION( ... )
17787 #define CATCH_DYNAMIC_SECTION( ... )
17788 #define CATCH_FAIL( ... ) (void)(0)
17789 #define CATCH_FAIL_CHECK( ... ) (void)(0)
17790 #define CATCH_SUCCEED( ... ) (void)(0)
17791
17792 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
17793
17794 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
17795 #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
17796 #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
17797 #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
17798 #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
17799 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
17800 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
17801 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17802 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17803 #else
17804 #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
17805 #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
17806 #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
17807 #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
17808 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
17809 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
17810 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17811 #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17812 #endif
17813
17814 // "BDD-style" convenience wrappers
17815 #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
17816 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
17817 #define CATCH_GIVEN( desc )
17818 #define CATCH_AND_GIVEN( desc )
17819 #define CATCH_WHEN( desc )
17820 #define CATCH_AND_WHEN( desc )
17821 #define CATCH_THEN( desc )
17822 #define CATCH_AND_THEN( desc )
17823
17824 #define CATCH_STATIC_REQUIRE( ... ) (void)(0)
17825 #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
17826
17827 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
17828 #else
17829
17830 #define REQUIRE( ... ) (void)(0)
17831 #define REQUIRE_FALSE( ... ) (void)(0)
17832
17833 #define REQUIRE_THROWS( ... ) (void)(0)
17834 #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
17835 #define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
17836 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17837 #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
17838 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17839 #define REQUIRE_NOTHROW( ... ) (void)(0)
17840
17841 #define CHECK( ... ) (void)(0)
17842 #define CHECK_FALSE( ... ) (void)(0)
17843 #define CHECKED_IF( ... ) if (__VA_ARGS__)
17844 #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
17845 #define CHECK_NOFAIL( ... ) (void)(0)
17846
17847 #define CHECK_THROWS( ... ) (void)(0)
17848 #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
17849 #define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
17850 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17851 #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
17852 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17853 #define CHECK_NOTHROW( ... ) (void)(0)
17854
17855 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
17856 #define CHECK_THAT( arg, matcher ) (void)(0)
17857
17858 #define REQUIRE_THAT( arg, matcher ) (void)(0)
17859 #endif // CATCH_CONFIG_DISABLE_MATCHERS
17860
17861 #define INFO( msg ) (void)(0)
17862 #define UNSCOPED_INFO( msg ) (void)(0)
17863 #define WARN( msg ) (void)(0)
17864 #define CAPTURE( msg ) (void)(0)
17865
17866 #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
17867 #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
17868 #define METHOD_AS_TEST_CASE( method, ... )
17869 #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
17870 #define SECTION( ... )
17871 #define DYNAMIC_SECTION( ... )
17872 #define FAIL( ... ) (void)(0)
17873 #define FAIL_CHECK( ... ) (void)(0)
17874 #define SUCCEED( ... ) (void)(0)
17875 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
17876
17877 #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
17878 #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
17879 #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
17880 #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
17881 #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
17882 #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
17883 #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
17884 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17885 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17886 #else
17887 #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
17888 #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
17889 #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
17890 #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
17891 #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
17892 #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
17893 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17894 #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
17895 #endif
17896
17897 #define STATIC_REQUIRE( ... ) (void)(0)
17898 #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
17899
17900 #endif
17901
17902 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
17903
17904 // "BDD-style" convenience wrappers
17905 #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
17906 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
17907
17908 #define GIVEN( desc )
17909 #define AND_GIVEN( desc )
17910 #define WHEN( desc )
17911 #define AND_WHEN( desc )
17912 #define THEN( desc )
17913 #define AND_THEN( desc )
17914
17915 using Catch::Detail::Approx;
17916
17917 #endif
17918
17919 #endif // ! CATCH_CONFIG_IMPL_ONLY
17920
17921 // start catch_reenable_warnings.h
17922
17923
17924 #ifdef __clang__
17925 # ifdef __ICC // icpc defines the __clang__ macro
17926 # pragma warning(pop)
17927 # else
17928 # pragma clang diagnostic pop
17929 # endif
17930 #elif defined __GNUC__
17931 # pragma GCC diagnostic pop
17932 #endif
17933
17934 // end catch_reenable_warnings.h
17935 // end catch.hpp
17936 #endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
17937
Resurrection of libmemcached