3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-26 07:16:10 +01:00
Code Issues Packages Projects Releases Wiki Activity
d32e89eb84
catch2/src/CMakeLists.txt

371 lines
15 KiB
CMake
Raw Normal View History

WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
include(MiscFunctions)
# Please keep these ordered alphabetically
set(BENCHMARK_HEADERS
${SOURCES_DIR}/benchmark/catch_benchmark.hpp
Add convenience headers that include all headers in a subpart The naming scheme is simple, to include all matchers, include header `catch2/matchers/catch_matchers_all.hpp`. To include **everything**, include `catch2/catch_all.hpp`.
2020-05-05 21:07:16 +02:00
${SOURCES_DIR}/benchmark/catch_benchmark_all.hpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/benchmark/catch_chronometer.hpp
${SOURCES_DIR}/benchmark/catch_clock.hpp
${SOURCES_DIR}/benchmark/catch_constructor.hpp
${SOURCES_DIR}/benchmark/catch_environment.hpp
${SOURCES_DIR}/benchmark/catch_estimate.hpp
${SOURCES_DIR}/benchmark/catch_execution_plan.hpp
${SOURCES_DIR}/benchmark/catch_optimizer.hpp
${SOURCES_DIR}/benchmark/catch_outlier_classification.hpp
${SOURCES_DIR}/benchmark/catch_sample_analysis.hpp
${SOURCES_DIR}/benchmark/detail/catch_analyse.hpp
${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.hpp
${SOURCES_DIR}/benchmark/detail/catch_complete_invoke.hpp
${SOURCES_DIR}/benchmark/detail/catch_estimate_clock.hpp
${SOURCES_DIR}/benchmark/detail/catch_measure.hpp
${SOURCES_DIR}/benchmark/detail/catch_repeat.hpp
${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.hpp
${SOURCES_DIR}/benchmark/detail/catch_stats.hpp
${SOURCES_DIR}/benchmark/detail/catch_timing.hpp
)
set(BENCHMARK_SOURCES
Introduce combined TUs for compiling small TUs This should improve the compilation times by decreasing the number of TUs compiled, without making overly big TUs that would cause problems with heavy-tailed compilation times. There is one "combined TU" for the top level part, and each subpart, except for Reporters, which currently do not have any trivial TUs.
2020-05-10 10:20:48 +02:00
${SOURCES_DIR}/benchmark/internal/catch_benchmark_combined_tu.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/benchmark/detail/catch_stats.cpp
)
SOURCE_GROUP("benchmark" FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})
set(INTERNAL_HEADERS
Add convenience headers that include all headers in a subpart The naming scheme is simple, to include all matchers, include header `catch2/matchers/catch_matchers_all.hpp`. To include **everything**, include `catch2/catch_all.hpp`.
2020-05-05 21:07:16 +02:00
${SOURCES_DIR}/catch_all.hpp
${SOURCES_DIR}/matchers/catch_matchers_all.hpp
${SOURCES_DIR}/generators/catch_generators_all.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_all.hpp
Move around matcher macro implementation
2020-04-26 21:33:55 +02:00
${SOURCES_DIR}/matchers/internal/catch_matchers_impl.hpp
Split out default CATCH_CONFIG_CONSOLE_WIDTH into its own header This means that code that uses it no longer has to include all of catch_config.hpp, which seems to provide significant reduction in size of unoptimized compilation of the final static library.
2020-08-01 19:09:18 +02:00
${SOURCES_DIR}/internal/catch_console_width.hpp
Add IsEmpty and SizeIs matchers for ranges/containers `SizeIs` can accept both `size_t` and a matcher. In the first case, it checks whether the size of the range is equal to specified size. In the second case, it checks whether the provided matcher accepts the size of the range.
2020-03-09 11:13:07 +01:00
${SOURCES_DIR}/internal/catch_container_nonmembers.hpp
Split the NonCopyable helper out of catch_common.hpp
2020-08-18 11:35:58 +02:00
${SOURCES_DIR}/internal/catch_noncopyable.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/catch_approx.hpp
Rename catch_assertionhandler -> catch_assertion_handler
2020-05-10 18:24:53 +02:00
${SOURCES_DIR}/internal/catch_assertion_handler.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/catch_assertion_info.hpp
${SOURCES_DIR}/catch_assertion_result.hpp
Rename catch_capture.hpp to more descriptive catch_test_macro_impl.hpp
2020-04-26 13:32:17 +02:00
${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
Split TestFailureException into its own header
2020-11-27 18:08:37 +01:00
${SOURCES_DIR}/internal/catch_test_failure_exception.hpp
Split out CaseSensitive enum out of catch_common.hpp Only very few places actually use it, so there is no need to have it be central to everywhere.
2020-08-18 13:11:30 +02:00
${SOURCES_DIR}/internal/catch_case_sensitive.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_clara.hpp
${SOURCES_DIR}/internal/catch_commandline.hpp
Rename catch_common.hpp -> catch_source_line_info.hpp Previous splitting of catch_common.hpp left it containing only one actual thing, which is the `SourceLineInfo` type. Given that, there is no reason to keep the old name. Also found out that it was included in some places for no reason (primarily Matchers).
2020-11-27 11:08:26 +01:00
${SOURCES_DIR}/internal/catch_source_line_info.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_config.hpp
Split CATCH_CONFIG_ANDROID_LOGWRITE into its own header Part of #2041
2020-12-28 11:21:04 +01:00
${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
Split CATCH_CONFIG_COUNTER into its own header Part of #2041
2020-12-29 11:07:45 +01:00
${SOURCES_DIR}/internal/catch_config_counter.hpp
Improve detection of std::uncaught_exceptions support The problem was that Catch2 did not reliably include `<exception>` before it checked for the feature test macro for `std::uncaught_exceptions`. To avoid overhead of including `<exception>` everywhere, the configuration check was split out into a separate header. Closes #2021
2020-10-06 11:07:53 +02:00
${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
Split CATCH_CONFIG_WCHAR into its own header Part of #2041
2020-12-28 20:29:05 +01:00
${SOURCES_DIR}/internal/catch_config_wchar.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_console_colour.hpp
${SOURCES_DIR}/internal/catch_context.hpp
${SOURCES_DIR}/internal/catch_debug_console.hpp
${SOURCES_DIR}/internal/catch_debugger.hpp
${SOURCES_DIR}/internal/catch_decomposer.hpp
${SOURCES_DIR}/internal/catch_enforce.hpp
${SOURCES_DIR}/internal/catch_enum_values_registry.hpp
${SOURCES_DIR}/internal/catch_errno_guard.hpp
${SOURCES_DIR}/internal/catch_exception_translator_registry.hpp
Small cleanup of fatal condition handler
2020-04-25 14:07:50 +02:00
${SOURCES_DIR}/internal/catch_fatal_condition_handler.hpp
Fix ulp distance calculation for numbers with different signs This is a simplification of the fix proposed in #2152, with the critical function split out so that it can be tested directly, without having to go through the ULP matcher. Closes #2152
2021-07-26 22:01:04 +02:00
${SOURCES_DIR}/internal/catch_floating_point_helpers.hpp
Split out INTERNAL_CATCH_UNIQUE_NAME into its own header Also small cleanup of includes of related headers.
2021-02-24 23:13:56 +01:00
${SOURCES_DIR}/internal/catch_unique_name.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/generators/catch_generator_exception.hpp
${SOURCES_DIR}/generators/catch_generators.hpp
${SOURCES_DIR}/generators/catch_generators_adapters.hpp
${SOURCES_DIR}/generators/catch_generators_random.hpp
${SOURCES_DIR}/generators/catch_generators_range.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_capture.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_config.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_enum_values_registry.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_exception.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_reporter.hpp
Split out ReporterFactory out of catch_interfaces_reporter.hpp
2020-08-23 21:19:26 +02:00
${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.hpp
Split IReporterRegistry into its own header file Doing this removes `<map>` from the include set of the base reporter interface, and thus from bunch more TUs. This provides about 1.5% improvements in the debug build of the static library, and 1% in release build.
2020-08-23 18:16:10 +02:00
${SOURCES_DIR}/interfaces/catch_interfaces_reporter_registry.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/interfaces/catch_interfaces_tag_alias_registry.hpp
${SOURCES_DIR}/interfaces/catch_interfaces_testcase.hpp
Split out LazyExpr into its own header This enables us to avoid `catch_reporter_bases.hpp` being indirectly dependent on `catch_tostring.hpp`, cutting apart quite a bit indirect inclusions.
2020-05-10 19:19:42 +02:00
${SOURCES_DIR}/internal/catch_lazy_expr.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_leak_detector.hpp
${SOURCES_DIR}/internal/catch_list.hpp
Standardize matcher headers to use .hpp suffix
2020-03-01 19:59:18 +01:00
${SOURCES_DIR}/matchers/catch_matchers.hpp
Add IsEmpty and SizeIs matchers for ranges/containers `SizeIs` can accept both `size_t` and a matcher. In the first case, it checks whether the size of the range is equal to specified size. In the second case, it checks whether the provided matcher accepts the size of the range.
2020-03-09 11:13:07 +01:00
${SOURCES_DIR}/matchers/catch_matchers_container_properties.hpp
Add generic Contains matcher It matches a range iff the range contains a specific element, or an element in the range matches the provided matcher.
2020-03-02 14:25:43 +01:00
${SOURCES_DIR}/matchers/catch_matchers_contains.hpp
Move matcher implementation to their own subfolder In the future we can expect many more matchers, so let's give them a place to live. Also moved matcher-related internal files to `internal` subfolder. Ideally we should sort out all of our source code, but that will have to come later.
2020-02-20 13:57:24 +01:00
${SOURCES_DIR}/matchers/catch_matchers_exception.hpp
Rename file catch_matchers_floating -> catch_matchers_floating_point The old name was a legacy of v2 era, where all headers were stitched into one. With v3 using separate headers, it is better when they have proper name.
2020-12-13 15:41:12 +01:00
${SOURCES_DIR}/matchers/catch_matchers_floating_point.hpp
Rename some matcher-related files The two changes are `catch_matchers_templates` -> `catch_matchers_templated` and `catch_matchers_generic` -> `catch_matchers_predicate`. The former is mostly cosmetic, but the second was previously significantly misleading, and as the library is now to be consumed by including specific headers, this needed to be fixed.
2020-03-18 15:57:11 +01:00
${SOURCES_DIR}/matchers/catch_matchers_predicate.hpp
Added AnyMatch, AllMatch and NoneMatch
2020-12-08 00:23:54 +01:00
${SOURCES_DIR}/matchers/catch_matchers_quantifiers.hpp
Standardize matcher headers to use .hpp suffix
2020-03-01 19:59:18 +01:00
${SOURCES_DIR}/matchers/catch_matchers_string.hpp
Rename some matcher-related files The two changes are `catch_matchers_templates` -> `catch_matchers_templated` and `catch_matchers_generic` -> `catch_matchers_predicate`. The former is mostly cosmetic, but the second was previously significantly misleading, and as the library is now to be consumed by including specific headers, this needed to be fixed.
2020-03-18 15:57:11 +01:00
${SOURCES_DIR}/matchers/catch_matchers_templated.hpp
Standardize matcher headers to use .hpp suffix
2020-03-01 19:59:18 +01:00
${SOURCES_DIR}/matchers/catch_matchers_vector.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/catch_message.hpp
Split MessageInfo into its own header This is first step towards splitting apart reporter implementation and `catch_string.hpp`.
2020-05-10 16:44:27 +02:00
${SOURCES_DIR}/internal/catch_message_info.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_meta.hpp
Add std::move/std::forward replacement macros Using the `CATCH_MOVE` and `CATCH_FORWARD` macros instead of the `std::move` and `std::forward<T>` utility functions can improve compilation times and debug build's performance, and thus will be preferred going forward.
2021-08-13 00:11:22 +02:00
${SOURCES_DIR}/internal/catch_move_and_forward.hpp
Rename Catch::Option to Optional
2021-10-05 20:11:42 +02:00
${SOURCES_DIR}/internal/catch_optional.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_output_redirect.hpp
${SOURCES_DIR}/internal/catch_platform.hpp
${SOURCES_DIR}/internal/catch_polyfills.hpp
${SOURCES_DIR}/internal/catch_preprocessor.hpp
${SOURCES_DIR}/internal/catch_random_number_generator.hpp
Add generateRandomSeed utility to generate randomness seed
2021-10-08 20:02:24 +02:00
${SOURCES_DIR}/internal/catch_random_seed_generation.hpp
Move reporter_registrars.hpp to reporters/
2021-11-10 23:52:59 +01:00
${SOURCES_DIR}/reporters/catch_reporter_registrars.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_reporter_registry.hpp
${SOURCES_DIR}/internal/catch_result_type.hpp
${SOURCES_DIR}/internal/catch_run_context.hpp
${SOURCES_DIR}/internal/catch_section.hpp
${SOURCES_DIR}/catch_section_info.hpp
${SOURCES_DIR}/catch_session.hpp
${SOURCES_DIR}/internal/catch_singletons.hpp
${SOURCES_DIR}/internal/catch_startup_exception_registry.hpp
${SOURCES_DIR}/internal/catch_stream.hpp
Split out the StreamEndStop helper into its own header
2020-11-27 10:43:07 +01:00
${SOURCES_DIR}/internal/catch_stream_end_stop.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_string_manip.hpp
Move StringRef header to internals
2020-05-10 10:09:01 +02:00
${SOURCES_DIR}/internal/catch_stringref.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/catch_tag_alias.hpp
${SOURCES_DIR}/catch_tag_alias_autoregistrar.hpp
${SOURCES_DIR}/internal/catch_tag_alias_registry.hpp
${SOURCES_DIR}/catch_test_case_info.hpp
${SOURCES_DIR}/internal/catch_test_case_registry_impl.hpp
${SOURCES_DIR}/internal/catch_test_case_tracker.hpp
Split TEMPLATE_TEST* macros into their own set of files These files are not included by the default `#include <catch2/catch_test_macros.hpp>` path, so that users do not have to pay for them if they do not use them. Follow up is to split out the small part of `catch_preprocessor.hpp` used by the default test macros (AFAIK, it is just `INTERNAL_CATCH_REMOVE_PARENS` macro), so that it is not included by the default path either. Also fixes #1892 by providing the missing macros.
2020-04-26 16:25:43 +02:00
${SOURCES_DIR}/catch_template_test_macros.hpp
Split the test macros into their own file
2020-01-19 16:01:50 +01:00
${SOURCES_DIR}/catch_test_macros.hpp
Split TEMPLATE_TEST* macros into their own set of files These files are not included by the default `#include <catch2/catch_test_macros.hpp>` path, so that users do not have to pay for them if they do not use them. Follow up is to split out the small part of `catch_preprocessor.hpp` used by the default test macros (AFAIK, it is just `INTERNAL_CATCH_REMOVE_PARENS` macro), so that it is not included by the default path either. Also fixes #1892 by providing the missing macros.
2020-04-26 16:25:43 +02:00
${SOURCES_DIR}/internal/catch_template_test_registry.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_test_registry.hpp
${SOURCES_DIR}/catch_test_spec.hpp
${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
Split TextFlow out from Clara Now that it has its own header, various reporter TUs that want to format text do not have to also include Clara. Together with outlining implementations from a header into a separate TU, this has noticeably improved the compilation times of the testing impl. As part of this split, I also implemented some improvements to the TextFlow code in comparison to the upstream code. These are: * Replaced the `Spacer` type with a free function that constructs special `Column` that does the same thing. * Generic performance improvements, such as eliminating needless allocations, reserving space in needed allocations, and using smarter algorithms in some places. * Because `Column` only ever stored 1 string in its vector, it now holds the string directly instead.
2020-08-01 20:32:26 +02:00
${SOURCES_DIR}/internal/catch_textflow.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/catch_timer.hpp
${SOURCES_DIR}/internal/catch_to_string.hpp
${SOURCES_DIR}/catch_tostring.hpp
${SOURCES_DIR}/catch_totals.hpp
Split CATCH_TRANSLATE_EXCEPTION into its own header As far as I know, only a few users actually use it, but these changes allow us to avoid including a surprising amount of code in the main compilation path.
2020-05-19 21:16:33 +02:00
${SOURCES_DIR}/catch_translate_exception.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_uncaught_exceptions.hpp
Implement a simplified variant of std::unique_ptr<T> This simplified variant supports only a subset of the functionality in `std::unique_ptr<T>`. `Catch::Detail::unique_ptr<T>` only supports single element pointer (no array support) with default deleter. By removing the support for custom deleters, we also avoid requiring significant machinery to support EBO, speeding up instantiations of `unique_ptr<T>` significantly. Catch2 also currently does not need to support `unique_ptr<T[]>`, so that is not supported either.
2020-05-24 23:41:02 +02:00
${SOURCES_DIR}/internal/catch_unique_ptr.hpp
Split void_type into its own header and rename it to void_t
2021-10-27 19:49:46 +02:00
${SOURCES_DIR}/internal/catch_void_type.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/catch_version.hpp
Separate version macros to its own header
2020-01-19 15:30:38 +01:00
${SOURCES_DIR}/catch_version_macros.hpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_wildcard_pattern.hpp
${SOURCES_DIR}/internal/catch_windows_h_proxy.hpp
${SOURCES_DIR}/internal/catch_xmlwriter.hpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
)
set(IMPL_SOURCES
${SOURCES_DIR}/catch_approx.cpp
Rename catch_assertionhandler -> catch_assertion_handler
2020-05-10 18:24:53 +02:00
${SOURCES_DIR}/internal/catch_assertion_handler.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/catch_assertion_result.cpp
Introduce combined TUs for compiling small TUs This should improve the compilation times by decreasing the number of TUs compiled, without making overly big TUs that would cause problems with heavy-tailed compilation times. There is one "combined TU" for the top level part, and each subpart, except for Reporters, which currently do not have any trivial TUs.
2020-05-10 10:20:48 +02:00
${SOURCES_DIR}/matchers/internal/catch_matchers_combined_tu.cpp
Clara cleanups * Clara is now split between a header and a cpp file. * Removed the deprecated `+` and `+=` operators for composing a parser. * Renamed `clara` and `detail` namespaces to be inline with the rest of Catch2 (they are now `Clara` and `Detail` respectively). * Taken most of user-exposed types out of the `Detail` namespace completely (instead of using `using` directives to bring them into the outer namespace).
2020-08-08 18:18:27 +02:00
${SOURCES_DIR}/internal/catch_clara.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_commandline.cpp
Rename catch_common.hpp -> catch_source_line_info.hpp Previous splitting of catch_common.hpp left it containing only one actual thing, which is the `SourceLineInfo` type. Given that, there is no reason to keep the old name. Also found out that it was included in some places for no reason (primarily Matchers).
2020-11-27 11:08:26 +01:00
${SOURCES_DIR}/internal/catch_source_line_info.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_config.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_console_colour.cpp
${SOURCES_DIR}/internal/catch_context.cpp
${SOURCES_DIR}/internal/catch_debug_console.cpp
${SOURCES_DIR}/internal/catch_debugger.cpp
${SOURCES_DIR}/internal/catch_enforce.cpp
${SOURCES_DIR}/internal/catch_enum_values_registry.cpp
${SOURCES_DIR}/internal/catch_exception_translator_registry.cpp
Small cleanup of fatal condition handler
2020-04-25 14:07:50 +02:00
${SOURCES_DIR}/internal/catch_fatal_condition_handler.cpp
Fix ulp distance calculation for numbers with different signs This is a simplification of the fix proposed in #2152, with the critical function split out so that it can be tested directly, without having to go through the ULP matcher. Closes #2152
2021-07-26 22:01:04 +02:00
${SOURCES_DIR}/internal/catch_floating_point_helpers.cpp
Introduce combined TUs for compiling small TUs This should improve the compilation times by decreasing the number of TUs compiled, without making overly big TUs that would cause problems with heavy-tailed compilation times. There is one "combined TU" for the top level part, and each subpart, except for Reporters, which currently do not have any trivial TUs.
2020-05-10 10:20:48 +02:00
${SOURCES_DIR}/generators/internal/catch_generators_combined_tu.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_combined_tu.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
${SOURCES_DIR}/internal/catch_list.cpp
Rename file catch_matchers_floating -> catch_matchers_floating_point The old name was a legacy of v2 era, where all headers were stitched into one. With v3 using separate headers, it is better when they have proper name.
2020-12-13 15:41:12 +01:00
${SOURCES_DIR}/matchers/catch_matchers_floating_point.cpp
Move matcher implementation to their own subfolder In the future we can expect many more matchers, so let's give them a place to live. Also moved matcher-related internal files to `internal` subfolder. Ideally we should sort out all of our source code, but that will have to come later.
2020-02-20 13:57:24 +01:00
${SOURCES_DIR}/matchers/catch_matchers_string.cpp
Rename some matcher-related files The two changes are `catch_matchers_templates` -> `catch_matchers_templated` and `catch_matchers_generic` -> `catch_matchers_predicate`. The former is mostly cosmetic, but the second was previously significantly misleading, and as the library is now to be consumed by including specific headers, this needed to be fixed.
2020-03-18 15:57:11 +01:00
${SOURCES_DIR}/matchers/catch_matchers_templated.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_message.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_output_redirect.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_registry_hub.cpp
Introduce combined TUs for compiling small TUs This should improve the compilation times by decreasing the number of TUs compiled, without making overly big TUs that would cause problems with heavy-tailed compilation times. There is one "combined TU" for the top level part, and each subpart, except for Reporters, which currently do not have any trivial TUs.
2020-05-10 10:20:48 +02:00
${SOURCES_DIR}/internal/catch_combined_tu.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_random_number_generator.cpp
Add generateRandomSeed utility to generate randomness seed
2021-10-08 20:02:24 +02:00
${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_reporter_registry.cpp
${SOURCES_DIR}/internal/catch_result_type.cpp
${SOURCES_DIR}/internal/catch_run_context.cpp
${SOURCES_DIR}/internal/catch_section.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_session.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_singletons.cpp
${SOURCES_DIR}/internal/catch_stream.cpp
${SOURCES_DIR}/internal/catch_stringref.cpp
${SOURCES_DIR}/internal/catch_string_manip.cpp
${SOURCES_DIR}/internal/catch_tag_alias_registry.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_test_case_info.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_test_case_registry_impl.cpp
${SOURCES_DIR}/internal/catch_test_case_tracker.cpp
${SOURCES_DIR}/internal/catch_test_registry.cpp
Split TextFlow out from Clara Now that it has its own header, various reporter TUs that want to format text do not have to also include Clara. Together with outlining implementations from a header into a separate TU, this has noticeably improved the compilation times of the testing impl. As part of this split, I also implemented some improvements to the TextFlow code in comparison to the upstream code. These are: * Replaced the `Spacer` type with a free function that constructs special `Column` that does the same thing. * Generic performance improvements, such as eliminating needless allocations, reserving space in needed allocations, and using smarter algorithms in some places. * Because `Column` only ever stored 1 string in its vector, it now holds the string directly instead.
2020-08-01 20:32:26 +02:00
${SOURCES_DIR}/internal/catch_textflow.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_test_spec.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_test_spec_parser.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/catch_timer.cpp
${SOURCES_DIR}/catch_tostring.cpp
${SOURCES_DIR}/catch_totals.cpp
${SOURCES_DIR}/catch_version.cpp
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_wildcard_pattern.cpp
${SOURCES_DIR}/internal/catch_xmlwriter.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
)
set(INTERNAL_FILES ${IMPL_SOURCES} ${INTERNAL_HEADERS})
# Please keep these ordered alphabetically
set(REPORTER_HEADERS
Add convenience headers that include all headers in a subpart The naming scheme is simple, to include all matchers, include header `catch2/matchers/catch_matchers_all.hpp`. To include **everything**, include `catch2/catch_all.hpp`.
2020-05-05 21:07:16 +02:00
${SOURCES_DIR}/reporters/catch_reporters_all.hpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/reporters/catch_reporter_automake.hpp
Rename reporters to use .hpp suffix I want to standardize _all_ of Catch2 headers on the `.hpp` suffix.
2020-04-04 21:53:23 +02:00
${SOURCES_DIR}/reporters/catch_reporter_compact.hpp
${SOURCES_DIR}/reporters/catch_reporter_console.hpp
Split catch_reporter_bases.hpp into two separate headers Each of the two reporter bases now has its own header file, and cpp file. Even though this adds another TU to the compilation, the total CPU time taken by compilation is reduced by about 1% for debug build and ~0.5% for optimized build of the main library. (The improvement would be roughly doubles without splitting the TUs, but the maintainability hit is not worth it.) The code size of the static library build has also somewhat decreased. Follow up: Introduce combined TU for reporters, and further split apart the catch_reporter_streaming_base.hpp header into its constituent parts, as it still contains a whole bunch of other stuff.
2020-08-22 23:16:23 +02:00
${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.hpp
Split EventListener base from streaming_base.hpp The base was also renamed from `TestEventListenerBase` to `EventListenerBase`, and modified to derive directly from the reporter interface, rather than deriving from `StreamingReporterBase`.
2020-08-24 22:52:59 +02:00
${SOURCES_DIR}/reporters/catch_reporter_event_listener.hpp
Split various reporter helpers out from streaming_base.hpp Due to also adding a new TU, there is no improvement to the compilation times of the static library, but it improves the compilation times of consumer's reporter TUs.
2020-08-23 22:43:56 +02:00
${SOURCES_DIR}/reporters/catch_reporter_helpers.hpp
Rename reporters to use .hpp suffix I want to standardize _all_ of Catch2 headers on the `.hpp` suffix.
2020-04-04 21:53:23 +02:00
${SOURCES_DIR}/reporters/catch_reporter_junit.hpp
${SOURCES_DIR}/reporters/catch_reporter_listening.hpp
Cleanup impl and main from the main header
2019-12-08 11:31:47 +01:00
${SOURCES_DIR}/reporters/catch_reporter_sonarqube.hpp
Split catch_reporter_bases.hpp into two separate headers Each of the two reporter bases now has its own header file, and cpp file. Even though this adds another TU to the compilation, the total CPU time taken by compilation is reduced by about 1% for debug build and ~0.5% for optimized build of the main library. (The improvement would be roughly doubles without splitting the TUs, but the maintainability hit is not worth it.) The code size of the static library build has also somewhat decreased. Follow up: Introduce combined TU for reporters, and further split apart the catch_reporter_streaming_base.hpp header into its constituent parts, as it still contains a whole bunch of other stuff.
2020-08-22 23:16:23 +02:00
${SOURCES_DIR}/reporters/catch_reporter_streaming_base.hpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/reporters/catch_reporter_tap.hpp
${SOURCES_DIR}/reporters/catch_reporter_teamcity.hpp
Rename reporters to use .hpp suffix I want to standardize _all_ of Catch2 headers on the `.hpp` suffix.
2020-04-04 21:53:23 +02:00
${SOURCES_DIR}/reporters/catch_reporter_xml.hpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
)
set(REPORTER_SOURCES
Cleanup impl and main from the main header
2019-12-08 11:31:47 +01:00
${SOURCES_DIR}/reporters/catch_reporter_automake.cpp
Split various reporter helpers out from streaming_base.hpp Due to also adding a new TU, there is no improvement to the compilation times of the static library, but it improves the compilation times of consumer's reporter TUs.
2020-08-23 22:43:56 +02:00
${SOURCES_DIR}/reporters/catch_reporter_combined_tu.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/reporters/catch_reporter_compact.cpp
${SOURCES_DIR}/reporters/catch_reporter_console.cpp
Split catch_reporter_bases.hpp into two separate headers Each of the two reporter bases now has its own header file, and cpp file. Even though this adds another TU to the compilation, the total CPU time taken by compilation is reduced by about 1% for debug build and ~0.5% for optimized build of the main library. (The improvement would be roughly doubles without splitting the TUs, but the maintainability hit is not worth it.) The code size of the static library build has also somewhat decreased. Follow up: Introduce combined TU for reporters, and further split apart the catch_reporter_streaming_base.hpp header into its constituent parts, as it still contains a whole bunch of other stuff.
2020-08-22 23:16:23 +02:00
${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/reporters/catch_reporter_junit.cpp
${SOURCES_DIR}/reporters/catch_reporter_listening.cpp
Cleanup impl and main from the main header
2019-12-08 11:31:47 +01:00
${SOURCES_DIR}/reporters/catch_reporter_sonarqube.cpp
Split catch_reporter_bases.hpp into two separate headers Each of the two reporter bases now has its own header file, and cpp file. Even though this adds another TU to the compilation, the total CPU time taken by compilation is reduced by about 1% for debug build and ~0.5% for optimized build of the main library. (The improvement would be roughly doubles without splitting the TUs, but the maintainability hit is not worth it.) The code size of the static library build has also somewhat decreased. Follow up: Introduce combined TU for reporters, and further split apart the catch_reporter_streaming_base.hpp header into its constituent parts, as it still contains a whole bunch of other stuff.
2020-08-22 23:16:23 +02:00
${SOURCES_DIR}/reporters/catch_reporter_streaming_base.cpp
Cleanup impl and main from the main header
2019-12-08 11:31:47 +01:00
${SOURCES_DIR}/reporters/catch_reporter_tap.cpp
${SOURCES_DIR}/reporters/catch_reporter_teamcity.cpp
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${SOURCES_DIR}/reporters/catch_reporter_xml.cpp
)
set(REPORTER_FILES ${REPORTER_HEADERS} ${REPORTER_SOURCES})
# Fixme: STATIC because for dynamic, we would need to handle visibility
# and I don't want to do the annotations right now
add_library(Catch2 STATIC
${REPORTER_FILES}
${INTERNAL_FILES}
${BENCHMARK_HEADERS}
${BENCHMARK_SOURCES}
)
Make the static library build reproducible with supported compilers This is based on bed285af07607a9da93892f8b08d36c3fd6af98d from `v2.x` branch, but done properly for the build in v3 branch, effectively porting #2141 to devel.
2021-05-09 17:36:30 +02:00
add_build_reproducibility_settings(Catch2)
Add Catch2::Catch2 alias for Catch2 CMake target
2020-05-11 20:05:10 +02:00
add_library(Catch2::Catch2 ALIAS Catch2)
Add Catch2Main CMake target that contains test main
2019-12-18 17:25:04 +01:00
Fixup installation
2019-12-16 22:33:56 +01:00
if (ANDROID)
target_link_libraries(Catch2 INTERFACE log)
endif()
Suffix the library name with 'd' for debug builds
2021-08-28 00:47:54 +02:00
set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "d")
Fixup installation
2019-12-16 22:33:56 +01:00
# depend on bunch of C++11 and C++14 features to have C++14 enabled by default
target_compile_features(Catch2
Add Catch2Main CMake target that contains test main
2019-12-18 17:25:04 +01:00
PUBLIC
Fixup installation
2019-12-16 22:33:56 +01:00
cxx_alignas
cxx_alignof
cxx_attributes
cxx_auto_type
cxx_constexpr
cxx_defaulted_functions
cxx_deleted_functions
cxx_final
cxx_lambdas
cxx_noexcept
cxx_override
cxx_range_for
cxx_rvalue_references
cxx_static_assert
cxx_strong_enums
cxx_trailing_return_types
cxx_unicode_literals
cxx_user_literals
cxx_variable_templates
cxx_variadic_macros
)
Add Catch2Main CMake target that contains test main
2019-12-18 17:25:04 +01:00
target_include_directories(Catch2
PUBLIC
$<BUILD_INTERFACE:${SOURCES_DIR}/..>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
Rename CMake/pkg-config target Catch2Main to Catch2WithMain This describes the reality better, as it also links in the rest of Catch2. The on-disk name of the static library remains just `Catch2Main`, as that is what it is -- single main function -- and on-disk artifacts cannot describe link dependencies.
2020-05-03 18:54:38 +02:00
add_library(Catch2WithMain STATIC
Standardize header names and file locations This is both a really big and a really small commit. It is small in that it only contains renaming, moving and modification of include directives caused by this. It is really big in the obvious way of touching something like 200 files. The new rules for naming files is simple: headers use the `.hpp` extension. The rules for physical file layout is still kinda in progress, but the basics are also simple: * Significant parts of functionality get their own subfolder * Benchmarking is in `catch2/benchmark` * Matchers are in `catch2/matchers` * Generators are in `catch2/generators` * Reporters are in `catch2/reporters` * Baseline testing facilities are in `catch2/` * Various top level folders also contain `internal` subfolder, with files that users probably do not want to include directly, at least not until they have to write something like their own reporter. * The exact files in these subfolders is likely to change later on Note that while some includes were cleaned up in this commit, it is only the low hanging fruit and further cleanup using automatic tooling will happen later. Also note that various include guards, copyright notices and file headers will also be standardized later, rather than in this commit.
2020-03-30 10:34:21 +02:00
${SOURCES_DIR}/internal/catch_main.cpp
Add Catch2Main CMake target that contains test main
2019-12-18 17:25:04 +01:00
)
Make the static library build reproducible with supported compilers This is based on bed285af07607a9da93892f8b08d36c3fd6af98d from `v2.x` branch, but done properly for the build in v3 branch, effectively porting #2141 to devel.
2021-05-09 17:36:30 +02:00
add_build_reproducibility_settings(Catch2WithMain)
Rename CMake/pkg-config target Catch2Main to Catch2WithMain This describes the reality better, as it also links in the rest of Catch2. The on-disk name of the static library remains just `Catch2Main`, as that is what it is -- single main function -- and on-disk artifacts cannot describe link dependencies.
2020-05-03 18:54:38 +02:00
add_library(Catch2::Catch2WithMain ALIAS Catch2WithMain)
target_link_libraries(Catch2WithMain PUBLIC Catch2)
set_target_properties(Catch2WithMain
PROPERTIES
OUTPUT_NAME "Catch2Main"
)
Suffix the library name with 'd' for debug builds
2021-08-28 00:47:54 +02:00
set_target_properties(Catch2WithMain PROPERTIES DEBUG_POSTFIX "d")
Add Catch2Main CMake target that contains test main
2019-12-18 17:25:04 +01:00
Fixup installation
2019-12-16 22:33:56 +01:00
if (NOT_SUBPROJECT)
# create and install an export set for catch target as Catch2::Catch
install(
TARGETS
Catch2
Rename CMake/pkg-config target Catch2Main to Catch2WithMain This describes the reality better, as it also links in the rest of Catch2. The on-disk name of the static library remains just `Catch2Main`, as that is what it is -- single main function -- and on-disk artifacts cannot describe link dependencies.
2020-05-03 18:54:38 +02:00
Catch2WithMain
Fixup installation
2019-12-16 22:33:56 +01:00
EXPORT
Catch2Targets
DESTINATION
${CMAKE_INSTALL_LIBDIR}
)
install(
EXPORT
Catch2Targets
NAMESPACE
Catch2::
DESTINATION
${CATCH_CMAKE_CONFIG_DESTINATION}
)
Add Catch2Main CMake target that contains test main
2019-12-18 17:25:04 +01:00
# Install the headers
Fixup installation
2019-12-16 22:33:56 +01:00
install(DIRECTORY ${SOURCES_DIR} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h*")
endif()
Redo how the separate compilation tests are handled
2019-12-15 20:33:39 +01:00
# Some tests require a full recompilation of Catch2 lib with different
# compilation flags. They can link against this target to recompile all
# the sources into the binary.
if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
add_library(Catch2_buildall_interface INTERFACE)
target_sources(Catch2_buildall_interface INTERFACE
Port the last example
2019-12-08 20:57:55 +01:00
${REPORTER_FILES}
${INTERNAL_FILES}
${BENCHMARK_HEADERS}
${BENCHMARK_SOURCES}
Remove catch_default_main.hpp There are two reasons for this: 1) It is highly unlikely that someone has use for this header, which has no customization points and only provides simplest possible main, and cannot link the static library which also provides a default main implementation. 2) It being a header was causing extra complications with the convenience headers, and our checking script. This would either require special handling in the checking script, or would break user's of the main convenience header. All in all, it is simpler and better in the long term to remove it, than to fix its problems.
2020-05-07 16:24:05 +02:00
# Also include main entry point
${SOURCES_DIR}/internal/catch_main.cpp
Port the last example
2019-12-08 20:57:55 +01:00
)
Redo how the separate compilation tests are handled
2019-12-15 20:33:39 +01:00
target_include_directories(Catch2_buildall_interface
INTERFACE
Port the last example
2019-12-08 20:57:55 +01:00
$<BUILD_INTERFACE:${SOURCES_DIR}/..>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
Add development build option to CMake and enable it on CI Development build enables warnings and and `Werror` or equivalent.
2020-02-21 21:15:45 +01:00
target_compile_features(Catch2_buildall_interface
INTERFACE
cxx_alignas
cxx_alignof
cxx_attributes
cxx_auto_type
cxx_constexpr
cxx_defaulted_functions
cxx_deleted_functions
cxx_final
cxx_lambdas
cxx_noexcept
cxx_override
cxx_range_for
cxx_rvalue_references
cxx_static_assert
cxx_strong_enums
cxx_trailing_return_types
cxx_unicode_literals
cxx_user_literals
cxx_variable_templates
cxx_variadic_macros
)
Redo how the separate compilation tests are handled
2019-12-15 20:33:39 +01:00
endif()
Add development build option to CMake and enable it on CI Development build enables warnings and and `Werror` or equivalent.
2020-02-21 21:15:45 +01:00
Rename CMake/pkg-config target Catch2Main to Catch2WithMain This describes the reality better, as it also links in the rest of Catch2. The on-disk name of the static library remains just `Catch2Main`, as that is what it is -- single main function -- and on-disk artifacts cannot describe link dependencies.
2020-05-03 18:54:38 +02:00
list(APPEND CATCH_WARNING_TARGETS Catch2 Catch2WithMain)
Add development build option to CMake and enable it on CI Development build enables warnings and and `Werror` or equivalent.
2020-02-21 21:15:45 +01:00
set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)
Reference in New Issue Copy Permalink