3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-22 21:36:11 +01:00
Code Issues Packages Projects Releases Wiki Activity
5cd8938905
catch2/src/CMakeLists.txt

472 lines
20 KiB
CMake
Raw Normal View History

Rename MiscFunctions.cmake -> CatchMiscFunctions.cmake
2022-02-07 00:05:11 +01:00
include(CatchMiscFunctions)
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
Generate Visual Studio project files with constant project guids By default, CMake derives a Visual Studio project GUID from the file path but the GUID can be overridden via a property (see https://gitlab.kitware.com/cmake/cmake/-/commit/c85367f4). Using a non-constant GUID can cause problems if other projects/repos want to reference the catch2 vcxproj files, so we force a constant GUID here. Signed-off-by: Alan Jowett <alanjo@microsoft.com> Resolves: #2388
2022-03-18 00:21:12 +01:00
# CMake derives a Visual Studio project GUID from the file path but can be overridden via a property
# (see https://gitlab.kitware.com/cmake/cmake/-/commit/c85367f4). Using a non-constant GUID
# can cause problems if other projects/repos want to reference the vcxproj file,
# so we force a constant GUID here.
set(Catch2_GUID_CMAKE "8d538cbe-01bf-4a2e-a98a-6c368fdf13d7" CACHE INTERNAL "Project GUID")
set(Catch2WithMain_GUID_CMAKE "8bd3552a-2cfb-4a59-ab15-2031b97ada1e" CACHE INTERNAL "Project GUID")
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
# 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
Split apart combined TUs The compile time improvements from using combined TUs mostly isn't worth the annoyance they cause with various IDE shortcuts, like when switching between header and its impl. file. Splitting them apart also fixes the issue of empty subdirs being installed due to `foo/internal` folders that only contained the combined TUs and no headers. Closes #2457 Closes #2463
2022-06-21 16:19:50 +02:00
${SOURCES_DIR}/benchmark/catch_chronometer.cpp
${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.cpp
${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.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
Allow passing compile-time configuration options through CMake
2022-02-02 15:36:58 +01:00
"${CMAKE_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
"${SOURCES_DIR}/catch_user_config.hpp.in"
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 CaseInsensitiveCmp into its own file
2021-12-26 00:27:11 +01:00
${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.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 IStream out of catch_stream.hpp
2022-04-16 14:43:40 +02:00
${SOURCES_DIR}/internal/catch_istream.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
Add catch_sharding.hpp to CML
2021-11-20 23:41:04 +01:00
${SOURCES_DIR}/internal/catch_sharding.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
Split REMOVE_PARENS from catch_preprocessor.hpp This way, some headers can include just the new header, which transitively decreases the total include size of test_macros.hpp.
2022-04-15 17:14:25 +02:00
${SOURCES_DIR}/internal/catch_preprocessor_remove_parens.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_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
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
Add splitReporterSpec helper
2022-04-04 11:54:02 +02:00
${SOURCES_DIR}/internal/catch_reporter_spec_parser.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_result_type.hpp
${SOURCES_DIR}/internal/catch_run_context.hpp
${SOURCES_DIR}/internal/catch_section.hpp
Split out Catch::cout/cerr/clog into their own file
2022-04-16 14:12:56 +02:00
${SOURCES_DIR}/internal/catch_stdstreams.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_section_info.hpp
${SOURCES_DIR}/catch_session.hpp
${SOURCES_DIR}/internal/catch_singletons.hpp
${SOURCES_DIR}/internal/catch_startup_exception_registry.hpp
Rename catch_stream -> catch_reusable_string_stream After everything else was split out, this name much reflects the actual contents of the file(s).
2022-04-16 15:00:41 +02:00
${SOURCES_DIR}/internal/catch_reusable_string_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
Allow easy retrieval of RNG seed by the users This makes it so that they don't need parallel RNG seed passing infrastructure for randomized data generation (e.g. inputs for benchmarks).
2022-08-18 21:22:28 +02:00
${SOURCES_DIR}/catch_get_random_seed.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_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
Added TestCaseInfoHasher and tests. (#2394) Test case hashing includes tags and class name As the hasher involves more code now, it was split out into its own file and it got its own set of tests. Closes #2304
2022-03-31 16:46:41 +02:00
${SOURCES_DIR}/internal/catch_test_case_info_hasher.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
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
Split out CaseInsensitiveCmp into its own file
2021-12-26 00:27:11 +01:00
${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.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
Split out IStream out of catch_stream.hpp
2022-04-16 14:43:40 +02:00
${SOURCES_DIR}/internal/catch_istream.cpp
Add support for retrieving generator's element as string
2022-05-16 16:34:06 +02:00
${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.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
Add AllTrue, AnyTrue, NoneTrue matchers
2021-11-14 17:05:31 +01:00
${SOURCES_DIR}/matchers/catch_matchers_quantifiers.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
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
Add splitReporterSpec helper
2022-04-04 11:54:02 +02:00
${SOURCES_DIR}/internal/catch_reporter_spec_parser.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_result_type.cpp
${SOURCES_DIR}/internal/catch_run_context.cpp
${SOURCES_DIR}/internal/catch_section.cpp
Split out Catch::cout/cerr/clog into their own file
2022-04-16 14:12:56 +02:00
${SOURCES_DIR}/internal/catch_stdstreams.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
Rename catch_stream -> catch_reusable_string_stream After everything else was split out, this name much reflects the actual contents of the file(s).
2022-04-16 15:00:41 +02:00
${SOURCES_DIR}/internal/catch_reusable_string_stream.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_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
Added TestCaseInfoHasher and tests. (#2394) Test case hashing includes tags and class name As the hasher involves more code now, it was split out into its own file and it got its own set of tests. Closes #2304
2022-03-31 16:46:41 +02:00
${SOURCES_DIR}/internal/catch_test_case_info_hasher.cpp
Make Random*Generators be seedable This is a necessary step to fix issue with combining multiple random generators in one test case, with different section nesting.
2022-05-17 17:57:15 +02:00
${SOURCES_DIR}/generators/catch_generators_random.cpp
Split apart combined TUs The compile time improvements from using combined TUs mostly isn't worth the annoyance they cause with various IDE shortcuts, like when switching between header and its impl. file. Splitting them apart also fixes the issue of empty subdirs being installed due to `foo/internal` folders that only contained the combined TUs and no headers. Closes #2457 Closes #2463
2022-06-21 16:19:50 +02:00
${SOURCES_DIR}/generators/catch_generator_exception.cpp
${SOURCES_DIR}/generators/catch_generators.cpp
${SOURCES_DIR}/matchers/catch_matchers.cpp
${SOURCES_DIR}/matchers/catch_matchers_container_properties.cpp
${SOURCES_DIR}/matchers/catch_matchers_exception.cpp
${SOURCES_DIR}/matchers/catch_matchers_predicate.cpp
${SOURCES_DIR}/matchers/internal/catch_matchers_impl.cpp
${SOURCES_DIR}/catch_tag_alias_autoregistrar.cpp
Allow easy retrieval of RNG seed by the users This makes it so that they don't need parallel RNG seed passing infrastructure for randomized data generation (e.g. inputs for benchmarks).
2022-08-18 21:22:28 +02:00
${SOURCES_DIR}/catch_get_random_seed.cpp
Split apart combined TUs The compile time improvements from using combined TUs mostly isn't worth the annoyance they cause with various IDE shortcuts, like when switching between header and its impl. file. Splitting them apart also fixes the issue of empty subdirs being installed due to `foo/internal` folders that only contained the combined TUs and no headers. Closes #2457 Closes #2463
2022-06-21 16:19:50 +02:00
${SOURCES_DIR}/internal/catch_decomposer.cpp
${SOURCES_DIR}/internal/catch_errno_guard.cpp
${SOURCES_DIR}/internal/catch_lazy_expr.cpp
${SOURCES_DIR}/internal/catch_leak_detector.cpp
${SOURCES_DIR}/internal/catch_message_info.cpp
${SOURCES_DIR}/internal/catch_polyfills.cpp
${SOURCES_DIR}/internal/catch_startup_exception_registry.cpp
${SOURCES_DIR}/internal/catch_uncaught_exceptions.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_capture.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_config.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_exception.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_reporter_registry.cpp
${SOURCES_DIR}/interfaces/catch_interfaces_testcase.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
Add common ReporterBase as parent of the helper bases This is useful as a centralized place for handling common reporter problems like handling output streams, and soon also colour impl handling.
2022-03-06 16:08:31 +01:00
${SOURCES_DIR}/reporters/catch_reporter_common_base.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
Rename listening reporter to multi reporter
2022-01-04 21:48:20 +01:00
${SOURCES_DIR}/reporters/catch_reporter_multi.hpp
Properly handle startup reporter registration errors
2022-05-15 10:35:07 +02:00
${SOURCES_DIR}/reporters/catch_reporter_registrars.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
Add common ReporterBase as parent of the helper bases This is useful as a centralized place for handling common reporter problems like handling output streams, and soon also colour impl handling.
2022-03-06 16:08:31 +01:00
${SOURCES_DIR}/reporters/catch_reporter_common_base.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
Split apart combined TUs The compile time improvements from using combined TUs mostly isn't worth the annoyance they cause with various IDE shortcuts, like when switching between header and its impl. file. Splitting them apart also fixes the issue of empty subdirs being installed due to `foo/internal` folders that only contained the combined TUs and no headers. Closes #2457 Closes #2463
2022-06-21 16:19:50 +02:00
${SOURCES_DIR}/reporters/catch_reporter_event_listener.cpp
${SOURCES_DIR}/reporters/catch_reporter_helpers.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
Rename listening reporter to multi reporter
2022-01-04 21:48:20 +01:00
${SOURCES_DIR}/reporters/catch_reporter_multi.cpp
Properly handle startup reporter registration errors
2022-05-15 10:35:07 +02:00
${SOURCES_DIR}/reporters/catch_reporter_registrars.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})
Allow building Catch2 as dynamic library Also have a check that warns users if they try to combined dynamic library with hidden visibility, which we do not support. Closes #2397 Closes #2398
2022-06-24 16:26:08 +02:00
add_library(Catch2
WIP: CMake changes to build static lib + tests separately
2019-11-30 17:41:41 +01:00
${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()
add versioning to shared libs (#2516) * add versioning to shared libs Co-authored-by: Martin Hořeňovský <martin.horenovsky@gmail.com>
2022-10-04 15:49:09 +02:00
set_target_properties(Catch2 PROPERTIES
DEBUG_POSTFIX "d"
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_VERSION})
Suffix the library name with 'd' for debug builds
2021-08-28 00:47:54 +02:00
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
)
Allow passing compile-time configuration options through CMake
2022-02-02 15:36:58 +01:00
configure_file(
"${SOURCES_DIR}/catch_user_config.hpp.in"
"${CMAKE_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
)
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}/..>
Allow passing compile-time configuration options through CMake
2022-02-02 15:36:58 +01:00
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated-includes>
Add Catch2Main CMake target that contains test main
2019-12-18 17:25:04 +01:00
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
Allow building Catch2 as dynamic library Also have a check that warns users if they try to combined dynamic library with hidden visibility, which we do not support. Closes #2397 Closes #2398
2022-06-24 16:26:08 +02:00
add_library(Catch2WithMain
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"
add versioning to shared libs (#2516) * add versioning to shared libs Co-authored-by: Martin Hořeňovský <martin.horenovsky@gmail.com>
2022-10-04 15:49:09 +02:00
VERSION ${PROJECT_VERSION}
SOVERSION ${PROJECT_VERSION}
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
)
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
Modify the install directories into convention.
2022-07-24 20:55:10 +02:00
LIBRARY DESTINATION
${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION
Fixup installation
2019-12-16 22:33:56 +01:00
${CMAKE_INSTALL_LIBDIR}
Modify the install directories into convention.
2022-07-24 20:55:10 +02:00
RUNTIME DESTINATION
${CMAKE_INSTALL_BINDIR}
Fixup installation
2019-12-16 22:33:56 +01:00
)
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
Allow passing compile-time configuration options through CMake
2022-02-02 15:36:58 +01:00
install(
DIRECTORY
"${SOURCES_DIR}"
"${CMAKE_BINARY_DIR}/generated-includes/catch2" # Also install the generated header
DESTINATION
"${CMAKE_INSTALL_INCLUDEDIR}"
FILES_MATCHING
PATTERN "*.hpp"
)
Fixup installation
2019-12-16 22:33:56 +01:00
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}/..>
Allow passing compile-time configuration options through CMake
2022-02-02 15:36:58 +01:00
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated-includes>
Port the last example
2019-12-08 20:57:55 +01:00
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
Fix building as shared library with MSVC.
2022-09-17 14:58:52 +02:00
target_compile_definitions(Catch2_buildall_interface
INTERFACE
CATCH_CONFIG_STATIC
)
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)
Allow building Catch2 as dynamic library Also have a check that warns users if they try to combined dynamic library with hidden visibility, which we do not support. Closes #2397 Closes #2398
2022-06-24 16:26:08 +02:00
# We still do not support building dynamic library with hidden visibility
# so we want to check & warn users if they do this. However, we won't abort
# the configuration step so that we don't have to also provide an override.
if (BUILD_SHARED_LIBS)
Redo visibility fallback
2022-06-27 13:10:22 +02:00
if (MSVC)
set_target_properties(Catch2 Catch2WithMain
PROPERTIES
WINDOWS_EXPORT_ALL_SYMBOLS ON
)
endif()
Allow building Catch2 as dynamic library Also have a check that warns users if they try to combined dynamic library with hidden visibility, which we do not support. Closes #2397 Closes #2398
2022-06-24 16:26:08 +02:00
Redo visibility fallback
2022-06-27 13:10:22 +02:00
get_target_property(_VisPreset Catch2 CXX_VISIBILITY_PRESET)
if (NOT MSVC AND _VisPreset STREQUAL "hidden")
set_target_properties(Catch2 Catch2WithMain
PROPERTIES
CXX_VISIBILITY_PRESET "default"
VISIBILITY_INLINES_HIDDEN OFF
Allow building Catch2 as dynamic library Also have a check that warns users if they try to combined dynamic library with hidden visibility, which we do not support. Closes #2397 Closes #2398
2022-06-24 16:26:08 +02:00
)
Redo visibility fallback
2022-06-27 13:10:22 +02:00
message(WARNING "Setting Catch2's visibility to default."
" Hidden visibility is not supported.")
Allow building Catch2 as dynamic library Also have a check that warns users if they try to combined dynamic library with hidden visibility, which we do not support. Closes #2397 Closes #2398
2022-06-24 16:26:08 +02:00
endif()
endif()
Reference in New Issue Copy Permalink