diff --git a/packages/Catch2/.bazelrc b/packages/Catch2/.bazelrc
index 55f17a67d6143ba16b89d5ae9ddb155fe1ca65d9..c01cb39f1d38a40ecaa7351113286de1da321aa7 100644
--- a/packages/Catch2/.bazelrc
+++ b/packages/Catch2/.bazelrc
@@ -1,4 +1,10 @@
+build --enable_platform_specific_config
+
build:gcc9 --cxxopt=-std=c++2a
+build:gcc11 --cxxopt=-std=c++2a
build:clang13 --cxxopt=-std=c++17
build:vs2019 --cxxopt=/std:c++17
-build:vs2022 --cxxopt=/std:c++17
\ No newline at end of file
+build:vs2022 --cxxopt=/std:c++17
+
+build:windows --config=vs2022
+build:linux --config=gcc11
diff --git a/packages/Catch2/.clang-format b/packages/Catch2/.clang-format
index 2a82aacfdcf07382b720d7706bf9ad60f4fc8402..9efb854dd2f49695e2f8c76e32143b178907bf61 100644
--- a/packages/Catch2/.clang-format
+++ b/packages/Catch2/.clang-format
@@ -1,25 +1,45 @@
---
-AccessModifierOffset: '-4'
+Language: Cpp
+Standard: c++14
+
+# Note that we cannot use IncludeIsMainRegex functionality, because it
+# does not support includes in angle brackets (<>)
+SortIncludes: true
+IncludeBlocks: Regroup
+IncludeCategories:
+ - Regex: <catch2/.*\.hpp>
+ Priority: 1
+ - Regex: <.*/.*\.hpp>
+ Priority: 2
+ - Regex: <.*>
+ Priority: 3
+
+AllowShortBlocksOnASingleLine: Always
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLambdasOnASingleLine: Inline
+
+AccessModifierOffset: "-4"
AlignEscapedNewlines: Left
-AllowAllConstructorInitializersOnNextLine: 'true'
-BinPackArguments: 'false'
-BinPackParameters: 'false'
+AllowAllConstructorInitializersOnNextLine: "true"
+BinPackArguments: "false"
+BinPackParameters: "false"
BreakConstructorInitializers: AfterColon
-ConstructorInitializerAllOnOneLineOrOnePerLine: 'true'
-DerivePointerAlignment: 'false'
-FixNamespaceComments: 'true'
-IncludeBlocks: Regroup
-IndentCaseLabels: 'false'
+ConstructorInitializerAllOnOneLineOrOnePerLine: "true"
+DerivePointerAlignment: "false"
+FixNamespaceComments: "true"
+IndentCaseLabels: "false"
IndentPPDirectives: AfterHash
-IndentWidth: '4'
-Language: Cpp
+IndentWidth: "4"
NamespaceIndentation: All
PointerAlignment: Left
-SpaceBeforeCtorInitializerColon: 'false'
-SpaceInEmptyParentheses: 'false'
-SpacesInParentheses: 'true'
-Standard: Cpp11
-TabWidth: '4'
+SpaceBeforeCtorInitializerColon: "false"
+SpaceInEmptyParentheses: "false"
+SpacesInParentheses: "true"
+TabWidth: "4"
UseTab: Never
-
-...
+AlwaysBreakTemplateDeclarations: Yes
+SpaceAfterTemplateKeyword: true
+SortUsingDeclarations: true
+ReflowComments: true
diff --git a/packages/Catch2/.github/workflows/linux-bazel-builds.yml b/packages/Catch2/.github/workflows/linux-bazel-builds.yml
new file mode 100644
index 0000000000000000000000000000000000000000..9006652e2c2874cd026725710eb061d77dd81ea2
--- /dev/null
+++ b/packages/Catch2/.github/workflows/linux-bazel-builds.yml
@@ -0,0 +1,24 @@
+name: Bazel build
+
+on: [push, pull_request]
+
+jobs:
+ build_and_test_ubuntu:
+ name: Linux Ubuntu 22.04 Bazel build <GCC 11.2.0>
+ runs-on: ubuntu-22.04
+ strategy:
+ matrix:
+ compilation_mode: [fastbuild, dbg, opt]
+
+ steps:
+ - uses: actions/checkout@v3
+
+ - name: Mount bazel cache
+ uses: actions/cache@v3
+ with:
+ path: "/home/runner/.cache/bazel"
+ key: bazel-ubuntu22-gcc11
+
+ - name: Build Catch2
+ run: |
+ bazelisk build --compilation_mode=${{matrix.compilation_mode}} //...
diff --git a/packages/Catch2/.github/workflows/linux-meson-builds.yml b/packages/Catch2/.github/workflows/linux-meson-builds.yml
new file mode 100644
index 0000000000000000000000000000000000000000..dec701b61b22217856030ebb1eb8773db0b1ccfc
--- /dev/null
+++ b/packages/Catch2/.github/workflows/linux-meson-builds.yml
@@ -0,0 +1,43 @@
+name: Linux builds (meson)
+
+on: [push, pull_request]
+
+jobs:
+ build:
+ name: meson ${{matrix.cxx}}, C++${{matrix.std}}, ${{matrix.build_type}}
+ runs-on: ubuntu-22.04
+ strategy:
+ matrix:
+ cxx:
+ - g++-11
+ - clang++-11
+ build_type: [debug, release]
+ std: [14, 17]
+ include:
+ - cxx: clang++-11
+ other_pkgs: clang-11
+
+ steps:
+ - uses: actions/checkout@v2
+
+ - name: Prepare environment
+ run: sudo apt-get install -y meson ninja-build ${{matrix.other_pkgs}}
+
+ - name: Configure build
+ env:
+ CXX: ${{matrix.cxx}}
+ CXXFLAGS: -std=c++${{matrix.std}} ${{matrix.cxxflags}}
+ # Note: $GITHUB_WORKSPACE is distinct from ${{runner.workspace}}.
+ # This is important
+ run: |
+ meson -Dbuildtype=${{matrix.build_type}} ${{runner.workspace}}/meson-build
+
+ - name: Build tests + lib
+ working-directory: ${{runner.workspace}}/meson-build
+ run: ninja
+
+ - name: Run tests
+ working-directory: ${{runner.workspace}}/meson-build
+ # Hardcode 2 cores we know are there
+ run: |
+ meson test --verbose
diff --git a/packages/Catch2/.github/workflows/linux-other-builds.yml b/packages/Catch2/.github/workflows/linux-other-builds.yml
index 31dcb92195bd6b61d7adef2a5b3274d4ac434476..cf4e2c06b755e6bbc0fdc7443f70d98e4420f29f 100644
--- a/packages/Catch2/.github/workflows/linux-other-builds.yml
+++ b/packages/Catch2/.github/workflows/linux-other-builds.yml
@@ -86,6 +86,7 @@ jobs:
cmake -Bbuild -H$GITHUB_WORKSPACE \
-DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-DCMAKE_CXX_STANDARD=${{matrix.std}} \
+ -DCMAKE_CXX_STANDARD_REQUIRED=ON \
-DCMAKE_CXX_EXTENSIONS=OFF \
-DCATCH_DEVELOPMENT_BUILD=ON \
${{matrix.cmake_configurations}} \
diff --git a/packages/Catch2/.github/workflows/linux-simple-builds.yml b/packages/Catch2/.github/workflows/linux-simple-builds.yml
index d7d4bb07f37d249ed49c84f808e70147f1b6fb1f..989c4942e221c4cdf8241f573f2f02a8d1f32546 100644
--- a/packages/Catch2/.github/workflows/linux-simple-builds.yml
+++ b/packages/Catch2/.github/workflows/linux-simple-builds.yml
@@ -9,7 +9,8 @@ jobs:
strategy:
matrix:
cxx:
-# - g++-6
+ - g++-5
+ - g++-6
- g++-7
- g++-8
- g++-9
@@ -22,9 +23,10 @@ jobs:
build_type: [Debug, Release]
std: [14]
include:
- # cannot be installed on ubuntu-20.04 be default?
-# - cxx: g++-6
-# other_pkgs: g++-6
+ - cxx: g++-5
+ other_pkgs: g++-5
+ - cxx: g++-6
+ other_pkgs: g++-6
- cxx: g++-7
other_pkgs: g++-7
- cxx: g++-8
@@ -63,10 +65,32 @@ jobs:
build_type: Release
std: 17
other_pkgs: clang-10
+ - cxx: clang++-10
+ build_type: Debug
+ std: 20
+ other_pkgs: clang-10
+ - cxx: clang++-10
+ build_type: Release
+ std: 20
+ other_pkgs: clang-10
+ - cxx: g++-10
+ build_type: Debug
+ std: 20
+ other_pkgs: g++-10
+ - cxx: g++-10
+ build_type: Release
+ std: 20
+ other_pkgs: g++-10
steps:
- uses: actions/checkout@v2
+ - name: Add repositories for older GCC
+ run: |
+ sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic main'
+ sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic universe'
+ if: ${{ matrix.cxx == 'g++-5' || matrix.cxx == 'g++-6' }}
+
- name: Prepare environment
run: sudo apt-get install -y ninja-build ${{matrix.other_pkgs}}
@@ -81,6 +105,7 @@ jobs:
cmake -Bbuild -H$GITHUB_WORKSPACE \
-DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
-DCMAKE_CXX_STANDARD=${{matrix.std}} \
+ -DCMAKE_CXX_STANDARD_REQUIRED=ON \
-DCMAKE_CXX_EXTENSIONS=OFF \
-DCATCH_DEVELOPMENT_BUILD=ON \
-G Ninja
diff --git a/packages/Catch2/.github/workflows/mac-builds.yml b/packages/Catch2/.github/workflows/mac-builds.yml
index 0ad5982dcc9b817790bf6472a63371adf7038355..955b81fcc6ea8514d84498ddd8123f2202561608 100644
--- a/packages/Catch2/.github/workflows/mac-builds.yml
+++ b/packages/Catch2/.github/workflows/mac-builds.yml
@@ -4,7 +4,11 @@ on: [push, pull_request]
jobs:
build:
- runs-on: macos-12
+ # macos-12 updated to a toolchain that crashes when linking the
+ # test binary. This seems to be a known bug in that version,
+ # and will eventually get fixed in an update. After that, we can go
+ # back to newer macos images.
+ runs-on: macos-11
strategy:
matrix:
cxx:
@@ -29,8 +33,11 @@ jobs:
# This is important
run: |
cmake -Bbuild -H$GITHUB_WORKSPACE \
- -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DCMAKE_CXX_STANDARD=${{matrix.std}} \
- -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_BUILD_EXAMPLES=${{matrix.examples}} \
+ -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+ -DCMAKE_CXX_STANDARD=${{matrix.std}} \
+ -DCMAKE_CXX_STANDARD_REQUIRED=ON \
+ -DCATCH_DEVELOPMENT_BUILD=ON \
+ -DCATCH_BUILD_EXAMPLES=${{matrix.examples}} \
-DCATCH_BUILD_EXTRA_TESTS=${{matrix.examples}}
- name: Build tests + lib
diff --git a/packages/Catch2/.github/workflows/windows-simple-builds.yml b/packages/Catch2/.github/workflows/windows-simple-builds.yml
new file mode 100644
index 0000000000000000000000000000000000000000..197fa219e3b2ac81d6734b2097b3eba8f69c5e87
--- /dev/null
+++ b/packages/Catch2/.github/workflows/windows-simple-builds.yml
@@ -0,0 +1,37 @@
+name: Windows builds (basic)
+
+on: [push, pull_request]
+
+jobs:
+ build:
+ name: ${{matrix.os}}, ${{matrix.std}}, ${{matrix.build_type}}, ${{matrix.platform}}
+ runs-on: ${{matrix.os}}
+ strategy:
+ matrix:
+ os: [windows-2019, windows-2022]
+ platform: [Win32, x64]
+ build_type: [Debug, Release]
+ std: [14, 17]
+ steps:
+ - uses: actions/checkout@v2
+
+ - name: Configure build
+ working-directory: ${{runner.workspace}}
+ run: |
+ cmake -S $Env:GITHUB_WORKSPACE `
+ -B ${{runner.workspace}}/build `
+ -DCMAKE_CXX_STANDARD=${{matrix.std}} `
+ -A ${{matrix.platform}} `
+ --preset all-tests
+
+ - name: Build tests
+ working-directory: ${{runner.workspace}}
+ run: cmake --build build --config ${{matrix.build_type}} --parallel %NUMBER_OF_PROCESSORS%
+ shell: cmd
+
+ - name: Run tests
+ working-directory: ${{runner.workspace}}/build
+ env:
+ CTEST_OUTPUT_ON_FAILURE: 1
+ run: ctest -C ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
+ shell: cmd
diff --git a/packages/Catch2/.gitignore b/packages/Catch2/.gitignore
index cafbd6b2979e841e857fe6b942525d70bf538c83..27f6bc0b30189079bc3cdd3cbbf2f0d96f50a9b4 100644
--- a/packages/Catch2/.gitignore
+++ b/packages/Catch2/.gitignore
@@ -1,4 +1,5 @@
*.build
+!meson.build
*.pbxuser
*.mode1v3
*.ncb
diff --git a/packages/Catch2/.gitrepo b/packages/Catch2/.gitrepo
index de961c79fcf1019990fc65996d7ebf36934f9eae..0b35a79b5e86abab214ceed2e6f119ed2eab73fc 100644
--- a/packages/Catch2/.gitrepo
+++ b/packages/Catch2/.gitrepo
@@ -6,7 +6,7 @@
[subrepo]
remote = git@github.com:catchorg/Catch2.git
branch = devel
- commit = 7b2e7d623b626ed2cae1d4b7f2b5480bdabbefd8
- parent = 95b3a702d689cb12fed8c321811e8afcff4485d4
+ commit = 0631b607ee2bbc07c7c238f0b15b23ef21926960
+ parent = 446a6502fc29873ba84cd5964ea2e0787dc48e49
method = merge
- cmdver = 0.4.3
+ cmdver = 0.4.6
diff --git a/packages/Catch2/BUILD.bazel b/packages/Catch2/BUILD.bazel
index 7c4435163104f15a226566e8f07ed68a47b29e33..02ec92265648334d09c039877202b2686609397e 100644
--- a/packages/Catch2/BUILD.bazel
+++ b/packages/Catch2/BUILD.bazel
@@ -1,14 +1,13 @@
-# Load the cc_library rule.
-load("@rules_cc//cc:defs.bzl", "cc_library")
load("@bazel_skylib//rules:expand_template.bzl", "expand_template")
expand_template(
name = "catch_user_config",
out = "catch2/catch_user_config.hpp",
substitutions = {
+ "@CATCH_CONFIG_CONSOLE_WIDTH@": "80",
+ "@CATCH_CONFIG_DEFAULT_REPORTER@": "console",
"#cmakedefine CATCH_CONFIG_ANDROID_LOGWRITE": "",
"#cmakedefine CATCH_CONFIG_BAZEL_SUPPORT": "#define CATCH_CONFIG_BAZEL_SUPPORT",
- "#cmakedefine CATCH_CONFIG_NO_COLOUR_WIN32": "",
"#cmakedefine CATCH_CONFIG_COLOUR_WIN32": "",
"#cmakedefine CATCH_CONFIG_COUNTER": "",
"#cmakedefine CATCH_CONFIG_CPP11_TO_STRING": "",
@@ -29,7 +28,10 @@ expand_template(
"#cmakedefine CATCH_CONFIG_EXPERIMENTAL_REDIRECT": "",
"#cmakedefine CATCH_CONFIG_FALLBACK_STRINGIFIER @CATCH_CONFIG_FALLBACK_STRINGIFIER@": "",
"#cmakedefine CATCH_CONFIG_FAST_COMPILE": "",
+ "#cmakedefine CATCH_CONFIG_GETENV": "",
"#cmakedefine CATCH_CONFIG_GLOBAL_NEXTAFTER": "",
+ "#cmakedefine CATCH_CONFIG_NO_ANDROID_LOGWRITE": "",
+ "#cmakedefine CATCH_CONFIG_NO_COLOUR_WIN32": "",
"#cmakedefine CATCH_CONFIG_NO_COUNTER": "",
"#cmakedefine CATCH_CONFIG_NO_CPP11_TO_STRING": "",
"#cmakedefine CATCH_CONFIG_NO_CPP17_BYTE": "",
@@ -37,21 +39,22 @@ expand_template(
"#cmakedefine CATCH_CONFIG_NO_CPP17_STRING_VIEW": "",
"#cmakedefine CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS": "",
"#cmakedefine CATCH_CONFIG_NO_CPP17_VARIANT": "",
+ "#cmakedefine CATCH_CONFIG_NO_GETENV": "",
"#cmakedefine CATCH_CONFIG_NO_GLOBAL_NEXTAFTER": "",
"#cmakedefine CATCH_CONFIG_NO_POSIX_SIGNALS": "",
"#cmakedefine CATCH_CONFIG_NO_USE_ASYNC": "",
+ "#cmakedefine CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT": "",
"#cmakedefine CATCH_CONFIG_NO_WCHAR": "",
"#cmakedefine CATCH_CONFIG_NO_WINDOWS_SEH": "",
"#cmakedefine CATCH_CONFIG_NOSTDOUT": "",
"#cmakedefine CATCH_CONFIG_POSIX_SIGNALS": "",
"#cmakedefine CATCH_CONFIG_PREFIX_ALL": "",
+ "#cmakedefine CATCH_CONFIG_SHARED_LIBRARY": "",
+ "#cmakedefine CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT": "",
"#cmakedefine CATCH_CONFIG_USE_ASYNC": "",
"#cmakedefine CATCH_CONFIG_WCHAR": "",
"#cmakedefine CATCH_CONFIG_WINDOWS_CRTDBG": "",
"#cmakedefine CATCH_CONFIG_WINDOWS_SEH": "",
- "#cmakedefine CATCH_CONFIG_NO_ANDROID_LOGWRITE": "",
- "@CATCH_CONFIG_DEFAULT_REPORTER@": "console",
- "@CATCH_CONFIG_CONSOLE_WIDTH@": "80",
},
template = "src/catch2/catch_user_config.hpp.in",
)
@@ -88,4 +91,4 @@ cc_library(
linkstatic = True,
visibility = ["//visibility:public"],
deps = [":catch2"],
-)
\ No newline at end of file
+)
diff --git a/packages/Catch2/CMake/CatchConfigOptions.cmake b/packages/Catch2/CMake/CatchConfigOptions.cmake
index a8ae93d43e7837caac719f75018a6b4d089d2252..067739dc9962a9349211dd735e7c93ea42964591 100644
--- a/packages/Catch2/CMake/CatchConfigOptions.cmake
+++ b/packages/Catch2/CMake/CatchConfigOptions.cmake
@@ -1,7 +1,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
@@ -40,6 +40,8 @@ set(_OverridableOptions
"USE_ASYNC"
"WCHAR"
"WINDOWS_SEH"
+ "GETENV"
+ "EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT"
)
foreach(OptionName ${_OverridableOptions})
@@ -67,6 +69,11 @@ set(_OtherConfigOptions
foreach(OptionName ${_OtherConfigOptions})
AddConfigOption(${OptionName})
endforeach()
+if(DEFINED BUILD_SHARED_LIBS)
+ set(CATCH_CONFIG_SHARED_LIBRARY ${BUILD_SHARED_LIBS})
+else()
+ set(CATCH_CONFIG_SHARED_LIBRARY "")
+endif()
set(CATCH_CONFIG_DEFAULT_REPORTER "console" CACHE STRING "Read docs/configuration.md for details. The name of the reporter should be without quotes.")
set(CATCH_CONFIG_CONSOLE_WIDTH "80" CACHE STRING "Read docs/configuration.md for details. Must form a valid integer literal.")
diff --git a/packages/Catch2/CMake/CatchMiscFunctions.cmake b/packages/Catch2/CMake/CatchMiscFunctions.cmake
index 73c8b4dd26a780e3276ec54fc6fec42a81dfa651..44c875007ff0717a1fea908d41c67dc8b22082f8 100644
--- a/packages/Catch2/CMake/CatchMiscFunctions.cmake
+++ b/packages/Catch2/CMake/CatchMiscFunctions.cmake
@@ -1,18 +1,19 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
include(CheckCXXCompilerFlag)
function(add_cxx_flag_if_supported_to_targets flagname targets)
- check_cxx_compiler_flag("${flagname}" HAVE_FLAG_${flagname})
+ string(MAKE_C_IDENTIFIER ${flagname} flag_identifier )
+ check_cxx_compiler_flag("${flagname}" HAVE_FLAG_${flag_identifier})
- if (HAVE_FLAG_${flagname})
+ if (HAVE_FLAG_${flag_identifier})
foreach(target ${targets})
- target_compile_options(${target} PUBLIC ${flagname})
+ target_compile_options(${target} PRIVATE ${flagname})
endforeach()
endif()
endfunction()
@@ -73,6 +74,7 @@ function(add_warnings_to_targets targets)
"-Woverloaded-virtual"
"-Wparentheses"
"-Wpedantic"
+ "-Wredundant-decls"
"-Wreorder"
"-Wreturn-std-move"
"-Wshadow"
@@ -82,7 +84,7 @@ function(add_warnings_to_targets targets)
"-Wundef"
"-Wuninitialized"
"-Wunneeded-internal-declaration"
- "-Wunreachable-code"
+ "-Wunreachable-code-aggressive"
"-Wunused"
"-Wunused-function"
"-Wunused-parameter"
@@ -112,9 +114,8 @@ endfunction()
# Adds flags required for reproducible build to the target
# Currently only supports GCC and Clang
function(add_build_reproducibility_settings target)
-# Make the build reproducible on versions of g++ and clang that supports -ffile-prefix-map
- if(("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" AND NOT ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 8) OR
- ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND NOT ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 10))
- target_compile_options(${target} PRIVATE "-ffile-prefix-map=${CATCH_DIR}=.")
+ # Make the build reproducible on versions of g++ and clang that supports -ffile-prefix-map
+ if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+ add_cxx_flag_if_supported_to_targets("-ffile-prefix-map=${CATCH_DIR}/=" "${target}")
endif()
endfunction()
diff --git a/packages/Catch2/CMakeLists.txt b/packages/Catch2/CMakeLists.txt
index ae8e86b9b9564ea914660612ceaaa5f642dc5f0f..b3e811538b11edc5f639f2f26abea21bc5e3a1bf 100644
--- a/packages/Catch2/CMakeLists.txt
+++ b/packages/Catch2/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.10)
# detect if Catch is being bundled,
# disable testsuite in that case
@@ -30,23 +30,15 @@ if (CMAKE_BINARY_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
message(FATAL_ERROR "Building in-source is not supported! Create a build dir and remove ${CMAKE_SOURCE_DIR}/CMakeCache.txt")
endif()
-if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.9)
- # Enable IPO for CMake versions that support it
- cmake_policy(SET CMP0069 NEW)
- project(Catch2
- VERSION 3.1.0 # CML version placeholder, don't delete
- LANGUAGES CXX
- # HOMEPAGE_URL is not supported until CMake version 3.12, which
- # we do not target yet.
- # HOMEPAGE_URL "https://github.com/catchorg/Catch2"
- DESCRIPTION "A modern, C++-native, unit test framework."
- )
-else()
- project(Catch2
- VERSION 3.1.0 # CML version placeholder, don't delete
- LANGUAGES CXX
- )
-endif()
+project(Catch2
+ VERSION 3.3.2 # CML version placeholder, don't delete
+ LANGUAGES CXX
+ # HOMEPAGE_URL is not supported until CMake version 3.12, which
+ # we do not target yet.
+ # HOMEPAGE_URL "https://github.com/catchorg/Catch2"
+ DESCRIPTION "A modern, C++-native, unit test framework."
+)
+
# Provide path for scripts. We first add path to the scripts we don't use,
# but projects including us might, and set the path up to parent scope.
@@ -156,6 +148,8 @@ if (NOT_SUBPROJECT)
"extras/ParseAndAddCatchTests.cmake"
"extras/Catch.cmake"
"extras/CatchAddTests.cmake"
+ "extras/CatchShardTests.cmake"
+ "extras/CatchShardTestsImpl.cmake"
DESTINATION
${CATCH_CMAKE_CONFIG_DESTINATION}
)
diff --git a/packages/Catch2/Doxyfile b/packages/Catch2/Doxyfile
index 6831841678725d6a4486a498d9a4c4acba9bad22..07b385ec10afb1a58a9647d1f4fb7882a3d0bf36 100644
--- a/packages/Catch2/Doxyfile
+++ b/packages/Catch2/Doxyfile
@@ -1319,7 +1319,7 @@ CHM_FILE =
HHC_LOCATION =
# The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
# The default value is: NO.
# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
diff --git a/packages/Catch2/README.md b/packages/Catch2/README.md
index 83fdf7b31a13bb12694c3a22b54b57dec7c1eb0a..3ea54a5d2c1423052b5959e023b0985d5411466c 100644
--- a/packages/Catch2/README.md
+++ b/packages/Catch2/README.md
@@ -1,5 +1,5 @@
<a id="top"></a>
-
+
[](https://github.com/catchorg/catch2/releases)
[](https://github.com/catchorg/Catch2/actions/workflows/linux-simple-builds.yml)
@@ -11,31 +11,82 @@
[](https://discord.gg/4CWS9zD)
-## What's the Catch2?
+## What is Catch2?
Catch2 is mainly a unit testing framework for C++, but it also
provides basic micro-benchmarking features, and simple BDD macros.
Catch2's main advantage is that using it is both simple and natural.
-Tests autoregister themselves and do not have to be named with valid
-identifiers, assertions look like normal C++ code, and sections provide
-a nice way to share set-up and tear-down code in tests.
+Test names do not have to be valid identifiers, assertions look like
+normal C++ boolean expressions, and sections provide a nice and local way
+to share set-up and tear-down code in tests.
+**Example unit test**
+```cpp
+#include <catch2/catch_test_macros.hpp>
-## Catch2 v3 is being developed!
+#include <cstdint>
-You are on the `devel` branch, where the next major version, v3, of
-Catch2 is being developed. As it is a significant rework, you will
-find that parts of this documentation are likely still stuck on v2.
+uint32_t factorial( uint32_t number ) {
+ return number <= 1 ? number : factorial(number-1) * number;
+}
-For stable (and documentation-matching) version of Catch2, [go to the
-`v2.x` branch](https://github.com/catchorg/Catch2/tree/v2.x).
+TEST_CASE( "Factorials are computed", "[factorial]" ) {
+ REQUIRE( factorial( 1) == 1 );
+ REQUIRE( factorial( 2) == 2 );
+ REQUIRE( factorial( 3) == 6 );
+ REQUIRE( factorial(10) == 3'628'800 );
+}
+```
+
+**Example microbenchmark**
+```cpp
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/benchmark/catch_benchmark.hpp>
+
+#include <cstdint>
+
+uint64_t fibonacci(uint64_t number) {
+ return number < 2 ? number : fibonacci(number - 1) + fibonacci(number - 2);
+}
+
+TEST_CASE("Benchmark Fibonacci", "[!benchmark]") {
+ REQUIRE(fibonacci(5) == 5);
+
+ REQUIRE(fibonacci(20) == 6'765);
+ BENCHMARK("fibonacci 20") {
+ return fibonacci(20);
+ };
+
+ REQUIRE(fibonacci(25) == 75'025);
+ BENCHMARK("fibonacci 25") {
+ return fibonacci(25);
+ };
+}
+```
+
+_Note that benchmarks are not run by default, so you need to run it explicitly
+with the `[!benchmark]` tag._
+
+
+## Catch2 v3 has been released!
+
+You are on the `devel` branch, where the v3 version is being developed.
+v3 brings a bunch of significant changes, the big one being that Catch2
+is no longer a single-header library. Catch2 now behaves as a normal
+library, with multiple headers and separately compiled implementation.
+
+The documentation is slowly being updated to take these changes into
+account, but this work is currently still ongoing.
For migrating from the v2 releases to v3, you should look at [our
documentation](docs/migrate-v2-to-v3.md#top). It provides a simple
guidelines on getting started, and collects most common migration
problems.
+For the previous major version of Catch2 [look into the `v2.x` branch
+here on GitHub](https://github.com/catchorg/Catch2/tree/v2.x).
+
## How to use it
This documentation comprises these three parts:
diff --git a/packages/Catch2/WORKSPACE b/packages/Catch2/WORKSPACE
deleted file mode 100644
index 2f265da0a095573e5ce933ea5c44483506ee5acb..0000000000000000000000000000000000000000
--- a/packages/Catch2/WORKSPACE
+++ /dev/null
@@ -1,14 +0,0 @@
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-
-http_archive(
- name = "bazel_skylib",
- strip_prefix = "bazel-skylib-2a87d4a62af886fb320883aba102255aba87275e",
- urls = [
- "https://github.com/bazelbuild/bazel-skylib/archive/2a87d4a62af886fb320883aba102255aba87275e.tar.gz",
- ],
- sha256 = "d847b08d6702d2779e9eb399b54ff8920fa7521dc45e3e53572d1d8907767de7",
-)
-
-load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
-
-bazel_skylib_workspace()
\ No newline at end of file
diff --git a/packages/Catch2/WORKSPACE.bazel b/packages/Catch2/WORKSPACE.bazel
new file mode 100644
index 0000000000000000000000000000000000000000..d962a99543e93cb4b43b46e7b051c02034eb4d43
--- /dev/null
+++ b/packages/Catch2/WORKSPACE.bazel
@@ -0,0 +1,16 @@
+workspace(name = "catch2")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+ name = "bazel_skylib",
+ sha256 = "b8a1527901774180afc798aeb28c4634bdccf19c4d98e7bdd1ce79d1fe9aaad7",
+ urls = [
+ "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.4.1/bazel-skylib-1.4.1.tar.gz",
+ "https://github.com/bazelbuild/bazel-skylib/releases/download/1.4.1/bazel-skylib-1.4.1.tar.gz",
+ ],
+)
+
+load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace")
+
+bazel_skylib_workspace()
diff --git a/packages/Catch2/appveyor.yml b/packages/Catch2/appveyor.yml
index a8f77df09a4ad9fdbcaeb8bf35db531351eb6795..3b6580d8bd7ab55ef9bbad9dda1bb0454c443677 100644
--- a/packages/Catch2/appveyor.yml
+++ b/packages/Catch2/appveyor.yml
@@ -51,18 +51,6 @@ test_script:
# build explicitly.
environment:
matrix:
- - FLAVOR: VS 2019 x64 Debug Surrogates Configure Tests
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
- surrogates: 1
- configure_tests: 1
- platform: x64
- configuration: Debug
-
- - FLAVOR: VS 2019 x64 Release
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
- platform: x64
- configuration: Release
-
- FLAVOR: VS 2019 x64 Debug Coverage Examples
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
examples: 1
@@ -77,11 +65,6 @@ environment:
platform: x64
configuration: Debug
- - FLAVOR: VS 2019 Win32 Debug
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
- platform: Win32
- configuration: Debug
-
- FLAVOR: VS 2019 x64 Debug Latest Strict
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
additional_flags: "/permissive- /std:c++latest"
@@ -92,38 +75,9 @@ environment:
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
platform: x64
configuration: Debug
-
- - FLAVOR: VS 2017 x64 Release
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
- platform: x64
- configuration: Release
- FLAVOR: VS 2017 x64 Release Coverage
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
coverage: 1
platform: x64
- configuration: Debug
-
- - FLAVOR: VS 2017 Win32 Debug
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
- platform: Win32
- configuration: Debug
-
- - FLAVOR: VS 2017 Win32 Debug Examples
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
- examples: 1
- platform: Win32
- configuration: Debug
-
- - FLAVOR: VS 2017 Win32 Debug WMain
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
- wmain: 1
- additional_flags: "/D_UNICODE /DUNICODE"
- platform: Win32
- configuration: Debug
-
- - FLAVOR: VS 2017 x64 Debug Latest Strict
- APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
- additional_flags: "/permissive- /std:c++latest"
- platform: x64
- configuration: Debug
+ configuration: Debug
\ No newline at end of file
diff --git a/packages/Catch2/data/artwork/catch2-logo-small-with-background.png b/packages/Catch2/data/artwork/catch2-logo-small-with-background.png
new file mode 100644
index 0000000000000000000000000000000000000000..963eaf492dcebd18a7fc1c9209f6e93c09d6ef18
Binary files /dev/null and b/packages/Catch2/data/artwork/catch2-logo-small-with-background.png differ
diff --git a/packages/Catch2/docs/Readme.md b/packages/Catch2/docs/Readme.md
index 1e59cf97ab32c2d81b66d4ee6b554f1cc6de2c81..d84b4bfdcc5bb785b51b4870eef7b8ee938b456a 100644
--- a/packages/Catch2/docs/Readme.md
+++ b/packages/Catch2/docs/Readme.md
@@ -4,34 +4,36 @@
To get the most out of Catch2, start with the [tutorial](tutorial.md#top).
Once you're up and running consider the following reference material.
-Writing tests:
+**Writing tests:**
* [Assertion macros](assertions.md#top)
-* [Matchers](matchers.md#top)
+* [Matchers (asserting complex properties)](matchers.md#top)
+* [Comparing floating point numbers](comparing-floating-point-numbers.md#top)
* [Logging macros](logging.md#top)
* [Test cases and sections](test-cases-and-sections.md#top)
* [Test fixtures](test-fixtures.md#top)
-* [Reporters](reporters.md#top)
+* [Explicitly skipping, passing, and failing tests at runtime](skipping-passing-failing.md#top)
+* [Reporters (output customization)](reporters.md#top)
* [Event Listeners](event-listeners.md#top)
-* [Data Generators](generators.md#top)
+* [Data Generators (value parameterized tests)](generators.md#top)
* [Other macros](other-macros.md#top)
* [Micro benchmarking](benchmarks.md#top)
-Fine tuning:
+**Fine tuning:**
* [Supplying your own main()](own-main.md#top)
* [Compile-time configuration](configuration.md#top)
* [String Conversions](tostring.md#top)
-Running:
+**Running:**
* [Command line](command-line.md#top)
-Odds and ends:
+**Odds and ends:**
* [Frequently Asked Questions (FAQ)](faq.md#top)
* [Best practices and other tips](usage-tips.md#top)
* [CMake integration](cmake-integration.md#top)
-* [CI and other miscellaneous pieces](ci-and-misc.md#top)
+* [Tooling integration (CI, test runners, other)](ci-and-misc.md#top)
* [Known limitations](limitations.md#top)
-
-Other:
+
+**Other:**
* [Why Catch2?](why-catch.md#top)
* [Migrating from v2 to v3](migrate-v2-to-v3.md#top)
* [Open Source Projects using Catch2](opensource-users.md#top)
diff --git a/packages/Catch2/docs/assertions.md b/packages/Catch2/docs/assertions.md
index 682eb6e7ce34615ee615e449e53acc2ccf42e9ac..40faa5ebcac2f0c94ca82edd98774a7a55f8274a 100644
--- a/packages/Catch2/docs/assertions.md
+++ b/packages/Catch2/docs/assertions.md
@@ -3,6 +3,7 @@
**Contents**<br>
[Natural Expressions](#natural-expressions)<br>
+[Floating point comparisons](#floating-point-comparisons)<br>
[Exceptions](#exceptions)<br>
[Matcher expressions](#matcher-expressions)<br>
[Thread Safety](#thread-safety)<br>
@@ -19,7 +20,7 @@ Most of these macros come in two forms:
The ```REQUIRE``` family of macros tests an expression and aborts the test case if it fails.
The ```CHECK``` family are equivalent but execution continues in the same test case even if the assertion fails. This is useful if you have a series of essentially orthogonal assertions and it is useful to see all the results rather than stopping at the first failure.
-* **REQUIRE(** _expression_ **)** and
+* **REQUIRE(** _expression_ **)** and
* **CHECK(** _expression_ **)**
Evaluates the expression and records the result. If an exception is thrown, it is caught, reported, and counted as a failure. These are the macros you will use most of the time.
@@ -31,98 +32,78 @@ CHECK( thisReturnsTrue() );
REQUIRE( i == 42 );
```
-* **REQUIRE_FALSE(** _expression_ **)** and
+Expressions prefixed with `!` cannot be decomposed. If you have a type
+that is convertible to bool and you want to assert that it evaluates to
+false, use the two forms below:
+
+
+* **REQUIRE_FALSE(** _expression_ **)** and
* **CHECK_FALSE(** _expression_ **)**
-Evaluates the expression and records the _logical NOT_ of the result. If an exception is thrown it is caught, reported, and counted as a failure.
-(these forms exist as a workaround for the fact that ! prefixed expressions cannot be decomposed).
+Note that there is no reason to use these forms for plain bool variables,
+because there is no added value in decomposing them.
Example:
+```cpp
+Status ret = someFunction();
+REQUIRE_FALSE(ret); // ret must evaluate to false, and Catch2 will print
+ // out the value of ret if possibly
```
-REQUIRE_FALSE( thisReturnsFalse() );
-```
-
-Do note that "overly complex" expressions cannot be decomposed and thus will not compile. This is done partly for practical reasons (to keep the underlying expression template machinery to minimum) and partly for philosophical reasons (assertions should be simple and deterministic).
-
-Examples:
-* `CHECK(a == 1 && b == 2);`
-This expression is too complex because of the `&&` operator. If you want to check that 2 or more properties hold, you can either put the expression into parenthesis, which stops decomposition from working, or you need to decompose the expression into two assertions: `CHECK( a == 1 ); CHECK( b == 2);`
-* `CHECK( a == 2 || b == 1 );`
-This expression is too complex because of the `||` operator. If you want to check that one of several properties hold, you can put the expression into parenthesis (unlike with `&&`, expression decomposition into several `CHECK`s is not possible).
-
-### Floating point comparisons
-When comparing floating point numbers - especially if at least one of them has been computed - great care must be taken to allow for rounding errors and inexact representations.
+### Other limitations
-Catch provides a way to perform tolerant comparisons of floating point values through use of a wrapper class called `Approx`. `Approx` can be used on either side of a comparison expression. It overloads the comparisons operators to take a tolerance into account. Here's a simple example:
+Note that expressions containing either of the binary logical operators,
+`&&` or `||`, cannot be decomposed and will not compile. The reason behind
+this is that it is impossible to overload `&&` and `||` in a way that
+keeps their short-circuiting semantics, and expression decomposition
+relies on overloaded operators to work.
-```cpp
-REQUIRE( performComputation() == Approx( 2.1 ) );
-```
+Simple example of an issue with overloading binary logical operators
+is a common pointer idiom, `p && p->foo == 2`. Using the built-in `&&`
+operator, `p` is only dereferenced if it is not null. With overloaded
+`&&`, `p` is always dereferenced, thus causing a segfault if
+`p == nullptr`.
-Catch also provides a user-defined literal for `Approx`; `_a`. It resides in
-the `Catch::literals` namespace and can be used like so:
-```cpp
-using namespace Catch::literals;
-REQUIRE( performComputation() == 2.1_a );
-```
+If you want to test expression that contains `&&` or `||`, you have two
+options.
-`Approx` is constructed with defaults that should cover most simple cases.
-For the more complex cases, `Approx` provides 3 customization points:
+1) Enclose it in parentheses. Parentheses force evaluation of the expression
+ before the expression decomposition can touch it, and thus it cannot
+ be used.
-* __epsilon__ - epsilon serves to set the coefficient by which a result
-can differ from `Approx`'s value before it is rejected.
-_By default set to `std::numeric_limits<float>::epsilon()*100`._
-* __margin__ - margin serves to set the the absolute value by which
-a result can differ from `Approx`'s value before it is rejected.
-_By default set to `0.0`._
-* __scale__ - scale is used to change the magnitude of `Approx` for relative check.
-_By default set to `0.0`._
+2) Rewrite the expression. `REQUIRE(a == 1 && b == 2)` can always be split
+ into `REQUIRE(a == 1); REQUIRE(b == 2);`. Alternatively, if this is a
+ common pattern in your tests, think about using [Matchers](#matcher-expressions).
+ instead. There is no simple rewrite rule for `||`, but I generally
+ believe that if you have `||` in your test expression, you should rethink
+ your tests.
-#### epsilon example
-```cpp
-Approx target = Approx(100).epsilon(0.01);
-100.0 == target; // Obviously true
-200.0 == target; // Obviously still false
-100.5 == target; // True, because we set target to allow up to 1% difference
-```
-#### margin example
-```cpp
-Approx target = Approx(100).margin(5);
-100.0 == target; // Obviously true
-200.0 == target; // Obviously still false
-104.0 == target; // True, because we set target to allow absolute difference of at most 5
-```
+## Floating point comparisons
-#### scale
-Scale can be useful if the computation leading to the result worked
-on different scale than is used by the results. Since allowed difference
-between Approx's value and compared value is based primarily on Approx's value
-(the allowed difference is computed as
-`(Approx::scale + Approx::value) * epsilon`), the resulting comparison could
-need rescaling to be correct.
+Comparing floating point numbers is complex, and [so it has its own
+documentation page](comparing-floating-point-numbers.md#top).
## Exceptions
-* **REQUIRE_NOTHROW(** _expression_ **)** and
+* **REQUIRE_NOTHROW(** _expression_ **)** and
* **CHECK_NOTHROW(** _expression_ **)**
Expects that no exception is thrown during evaluation of the expression.
-* **REQUIRE_THROWS(** _expression_ **)** and
+* **REQUIRE_THROWS(** _expression_ **)** and
* **CHECK_THROWS(** _expression_ **)**
Expects that an exception (of any type) is be thrown during evaluation of the expression.
-* **REQUIRE_THROWS_AS(** _expression_, _exception type_ **)** and
+* **REQUIRE_THROWS_AS(** _expression_, _exception type_ **)** and
* **CHECK_THROWS_AS(** _expression_, _exception type_ **)**
Expects that an exception of the _specified type_ is thrown during evaluation of the expression. Note that the _exception type_ is extended with `const&` and you should not include it yourself.
-* **REQUIRE_THROWS_WITH(** _expression_, _string or string matcher_ **)** and
+* **REQUIRE_THROWS_WITH(** _expression_, _string or string matcher_ **)** and
* **CHECK_THROWS_WITH(** _expression_, _string or string matcher_ **)**
Expects that an exception is thrown that, when converted to a string, matches the _string_ or _string matcher_ provided (see next section for Matchers).
@@ -158,8 +139,8 @@ REQUIRE_NOTHROW([&](){
To support Matchers a slightly different form is used. Matchers have [their own documentation](matchers.md#top).
-* **REQUIRE_THAT(** _lhs_, _matcher expression_ **)** and
-* **CHECK_THAT(** _lhs_, _matcher expression_ **)**
+* **REQUIRE_THAT(** _lhs_, _matcher expression_ **)** and
+* **CHECK_THAT(** _lhs_, _matcher expression_ **)**
Matchers can be composed using `&&`, `||` and `!` operators.
diff --git a/packages/Catch2/docs/ci-and-misc.md b/packages/Catch2/docs/ci-and-misc.md
index ef9dff24cafacc3109d1dd948377512e67729746..c07da29f056a8ab3df96863475436f757e814e66 100644
--- a/packages/Catch2/docs/ci-and-misc.md
+++ b/packages/Catch2/docs/ci-and-misc.md
@@ -1,8 +1,15 @@
<a id="top"></a>
-# CI and other odd pieces
+# Tooling integration (CI, test runners and so on)
+
+**Contents**<br>
+[Continuous Integration systems](#continuous-integration-systems)<br>
+[Bazel test runner integration](#bazel-test-runner-integration)<br>
+[Low-level tools](#low-level-tools)<br>
+[CMake](#cmake)<br>
+
+This page talks about Catch2's integration with other related tooling,
+like Continuous Integration and 3rd party test runners.
-This page talks about how Catch integrates with Continuous Integration
-Build Systems may refer to low-level tools, like CMake, or larger systems that run on servers, like Jenkins or TeamCity. This page will talk about both.
## Continuous Integration systems
@@ -11,9 +18,9 @@ Probably the most important aspect to using Catch with a build server is the use
Two of these reporters are built in (XML and JUnit) and the third (TeamCity) is included as a separate header. It's possible that the other two may be split out in the future too - as that would make the core of Catch smaller for those that don't need them.
### XML Reporter
-```-r xml```
+```-r xml```
-The XML Reporter writes in an XML format that is specific to Catch.
+The XML Reporter writes in an XML format that is specific to Catch.
The advantage of this format is that it corresponds well to the way Catch works (especially the more unusual features, such as nested sections) and is a fully streaming format - that is it writes output as it goes, without having to store up all its results before it can start writing.
@@ -51,6 +58,26 @@ Because of the incremental nature of Catch's test suites and ability to run spec
[SonarQube Generic Test Data](https://docs.sonarqube.org/latest/analysis/generic-test/) XML format for tests metrics.
+## Bazel test runner integration
+
+Catch2 understands some of the environment variables Bazel uses to control
+test execution. Specifically it understands
+
+ * JUnit output path via `XML_OUTPUT_FILE`
+ * Test filtering via `TESTBRIDGE_TEST_ONLY`
+ * Test sharding via `TEST_SHARD_INDEX`, `TEST_TOTAL_SHARDS`, and `TEST_SHARD_STATUS_FILE`
+
+> Support for `XML_OUTPUT_FILE` was [introduced](https://github.com/catchorg/Catch2/pull/2399) in Catch2 3.0.1
+
+> Support for `TESTBRIDGE_TEST_ONLY` and sharding was introduced in Catch2 3.2.0
+
+This integration is enabled via either a [compile time configuration
+option](configuration.md#bazel-support), or via `BAZEL_TEST` environment
+variable set to "1".
+
+> Support for `BAZEL_TEST` was [introduced](https://github.com/catchorg/Catch2/pull/2459) in Catch2 3.1.0
+
+
## Low-level tools
### CodeCoverage module (GCOV, LCOV...)
diff --git a/packages/Catch2/docs/cmake-integration.md b/packages/Catch2/docs/cmake-integration.md
index dc3efc9d9f4c578476d33fe54b20b6564eaddc54..e38d5c2f40d28a46aa6b65c22a6c9c6ce0e32bea 100644
--- a/packages/Catch2/docs/cmake-integration.md
+++ b/packages/Catch2/docs/cmake-integration.md
@@ -90,12 +90,12 @@ cmake_minimum_required(VERSION 3.5)
project(baz LANGUAGES CXX VERSION 0.0.1)
find_package(Catch2 REQUIRED)
-add_executable(foo test.cpp)
-target_link_libraries(foo PRIVATE Catch2::Catch2)
+add_executable(tests test.cpp)
+target_link_libraries(tests PRIVATE Catch2::Catch2)
include(CTest)
include(Catch)
-catch_discover_tests(foo)
+catch_discover_tests(tests)
```
When using `FetchContent`, `include(Catch)` will fail unless
@@ -108,11 +108,11 @@ directory.
list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
include(CTest)
include(Catch)
-catch_discover_tests()
+catch_discover_tests(tests)
```
#### Customization
-`catch_discover_tests` can be given several extra argumets:
+`catch_discover_tests` can be given several extra arguments:
```cmake
catch_discover_tests(target
[TEST_SPEC arg1...]
@@ -126,6 +126,7 @@ catch_discover_tests(target
[OUTPUT_DIR dir]
[OUTPUT_PREFIX prefix]
[OUTPUT_SUFFIX suffix]
+ [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
)
```
@@ -198,6 +199,16 @@ If specified, `suffix` is added to each output file name, like so
`--out dir/<test_name>suffix`. This can be used to add a file extension to
the output file name e.g. ".xml".
+* `DISCOVERY_MODE mode`
+
+If specified allows control over when test discovery is performed.
+For a value of `POST_BUILD` (default) test discovery is performed at build time.
+For a a value of `PRE_TEST` test discovery is delayed until just prior to test
+execution (useful e.g. in cross-compilation environments).
+``DISCOVERY_MODE`` defaults to the value of the
+``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
+calling ``catch_discover_tests``. This provides a mechanism for globally
+selecting a preferred test discovery behavior.
### `ParseAndAddCatchTests.cmake`
@@ -222,12 +233,12 @@ cmake_minimum_required(VERSION 3.5)
project(baz LANGUAGES CXX VERSION 0.0.1)
find_package(Catch2 REQUIRED)
-add_executable(foo test.cpp)
-target_link_libraries(foo PRIVATE Catch2::Catch2)
+add_executable(tests test.cpp)
+target_link_libraries(tests PRIVATE Catch2::Catch2)
include(CTest)
include(ParseAndAddCatchTests)
-ParseAndAddCatchTests(foo)
+ParseAndAddCatchTests(tests)
```
diff --git a/packages/Catch2/docs/command-line.md b/packages/Catch2/docs/command-line.md
index 218e2f596e4ec89c68fbeaee9f93d5d22f0b6584..a15a213147b3b4ed8a34a8402fd287f0d82ef5cd 100644
--- a/packages/Catch2/docs/command-line.md
+++ b/packages/Catch2/docs/command-line.md
@@ -148,7 +148,7 @@ validity, and throw an error if they are wrong._
> Support for passing arguments to reporters through the `-r`, `--reporter` flag was introduced in Catch2 3.0.1
There are multiple built-in reporters, you can see what they do by using the
-[`--list-reporter`](command-line.md#listing-available-tests-tags-or-reporters)
+[`--list-reporters`](command-line.md#listing-available-tests-tags-or-reporters)
flag. If you need a reporter providing custom format outside of the already
provided ones, look at the ["write your own reporter" part of the reporter
documentation](reporters.md#writing-your-own-reporter).
@@ -284,7 +284,7 @@ This option transforms tabs and newline characters into ```\t``` and ```\n``` re
<pre>-w, --warn <warning name></pre>
You can think of Catch2's warnings as the equivalent of `-Werror` (`/WX`)
-flag for C++ compilers. It turns some suspicious occurences, like a section
+flag for C++ compilers. It turns some suspicious occurrences, like a section
without assertions, into errors. Because these might be intended, warnings
are not enabled by default, but user can opt in.
@@ -313,7 +313,7 @@ When set to ```yes``` Catch will report the duration of each test case, in milli
> `--min-duration` was [introduced](https://github.com/catchorg/Catch2/pull/1910) in Catch2 2.13.0
When set, Catch will report the duration of each test case that took more
-than <value> seconds, in milliseconds. This option is overriden by both
+than <value> seconds, in milliseconds. This option is overridden by both
`-d yes` and `-d no`, so that either all durations are reported, or none
are.
@@ -339,8 +339,8 @@ Test cases are ordered one of three ways:
### decl
Declaration order (this is the default order if no --order argument is provided).
-Tests in the same TU are sorted using their declaration orders, different
-TUs are in an implementation (linking) dependent order.
+Tests in the same translation unit are sorted using their declaration orders,
+different TUs are sorted in an implementation (linking) dependent order.
### lex
@@ -507,10 +507,13 @@ start of the first section.</br>
## Filenames as tags
<pre>-#, --filenames-as-tags</pre>
-When this option is used then every test is given an additional tag which is formed of the unqualified
-filename it is found in, with any extension stripped, prefixed with the `#` character.
+This option adds an extra tag to all test cases. The tag is `#` followed
+by the unqualified filename the test case is defined in, with the _last_
+extension stripped out.
+
+For example, tests within the file `tests\SelfTest\UsageTests\BDD.tests.cpp`
+will be given the `[#BDD.tests]` tag.
-So, for example, tests within the file `~\Dev\MyProject\Ferrets.cpp` would be tagged `[#Ferrets]`.
<a id="colour-mode"></a>
## Override output colouring
@@ -548,7 +551,8 @@ starting at 0. The tests in the set given by
`--shard-index <#shard index to run>` will be executed. The default shard
count is `1`, and the default index to run is `0`.
-_It is an error to specify a shard index greater than the number of shards._
+_Shard index must be less than number of shards. As the name suggests,
+it is treated as an index of the shard to run._
Sharding is useful when you want to split test execution across multiple
processes, as is done with the [Bazel test sharding](https://docs.bazel.build/versions/main/test-encyclopedia.html#test-sharding).
@@ -560,17 +564,17 @@ processes, as is done with the [Bazel test sharding](https://docs.bazel.build/ve
> Introduced in Catch2 3.0.1.
-By default, Catch2 test binaries return non-0 exit code if no tests were
-run, e.g. if the binary was compiled with no tests, or the provided test
-spec matched no tests. This flag overrides that, so a test run with no
-tests still returns 0.
+By default, Catch2 test binaries return non-0 exit code if no tests were run,
+e.g. if the binary was compiled with no tests, the provided test spec matched no
+tests, or all tests [were skipped at runtime](skipping-passing-failing.md#top). This flag
+overrides that, so a test run with no tests still returns 0.
## Output verbosity
```
-v, --verbosity <quiet|normal|high>
```
-Changing verbosity might change how much details Catch2's reporters output.
+Changing verbosity might change how many details Catch2's reporters output.
However, you should consider changing the verbosity level as a _suggestion_.
Not all reporters support all verbosity levels, e.g. because the reporter's
format cannot meaningfully change. In that case, the verbosity level is
diff --git a/packages/Catch2/docs/commercial-users.md b/packages/Catch2/docs/commercial-users.md
index bb41e741e7e84f17f0291ddbb85f95488de748c1..020eaefcb3d2ed158e28a50effb7c7d1159dec83 100644
--- a/packages/Catch2/docs/commercial-users.md
+++ b/packages/Catch2/docs/commercial-users.md
@@ -6,7 +6,7 @@ some of them that are willing to share this information.
If you want to add your organisation, please check that there is no issue
with you sharing this fact.
-
+
- Bloomberg
- [Bloomlife](https://bloomlife.com)
- [Inscopix Inc.](https://www.inscopix.com/)
@@ -16,7 +16,7 @@ with you sharing this fact.
- [Nexus Software Systems](https://nexwebsites.com)
- [UX3D](https://ux3d.io)
- [King](https://king.com)
-
+
---
diff --git a/packages/Catch2/docs/comparing-floating-point-numbers.md b/packages/Catch2/docs/comparing-floating-point-numbers.md
new file mode 100644
index 0000000000000000000000000000000000000000..ab5ba6df6cbc3181c977973856b64d37e165da21
--- /dev/null
+++ b/packages/Catch2/docs/comparing-floating-point-numbers.md
@@ -0,0 +1,192 @@
+<a id="top"></a>
+# Comparing floating point numbers with Catch2
+
+If you are not deeply familiar with them, floating point numbers can be
+unintuitive. This also applies to comparing floating point numbers for
+(in)equality.
+
+This page assumes that you have some understanding of both FP, and the
+meaning of different kinds of comparisons, and only goes over what
+functionality Catch2 provides to help you with comparing floating point
+numbers. If you do not have this understanding, we recommend that you first
+study up on floating point numbers and their comparisons, e.g. by [reading
+this blog post](https://codingnest.com/the-little-things-comparing-floating-point-numbers/).
+
+
+## Floating point matchers
+
+```
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+```
+
+[Matchers](matchers.md#top) are the preferred way of comparing floating
+point numbers in Catch2. We provide 3 of them:
+
+* `WithinAbs(double target, double margin)`,
+* `WithinRel(FloatingPoint target, FloatingPoint eps)`, and
+* `WithinULP(FloatingPoint target, uint64_t maxUlpDiff)`.
+
+> `WithinRel` matcher was introduced in Catch2 2.10.0
+
+As with all matchers, you can combine multiple floating point matchers
+in a single assertion. For example, to check that some computation matches
+a known good value within 0.1% or is close enough (no different to 5
+decimal places) to zero, we would write this assertion:
+
+```cpp
+ REQUIRE_THAT( computation(input),
+ Catch::Matchers::WithinRel(expected, 0.001)
+ || Catch::Matchers::WithinAbs(0, 0.000001) );
+```
+
+
+### WithinAbs
+
+`WithinAbs` creates a matcher that accepts floating point numbers whose
+difference with `target` is less-or-equal to the `margin`. Since `float`
+can be converted to `double` without losing precision, only `double`
+overload exists.
+
+```cpp
+REQUIRE_THAT(1.0, WithinAbs(1.2, 0.2));
+REQUIRE_THAT(0.f, !WithinAbs(1.0, 0.5));
+// Notice that infinity == infinity for WithinAbs
+REQUIRE_THAT(INFINITY, WithinAbs(INFINITY, 0));
+```
+
+
+### WithinRel
+
+`WithinRel` creates a matcher that accepts floating point numbers that
+are _approximately equal_ to the `target` with a tolerance of `eps.`
+Specifically, it matches if
+`|arg - target| <= eps * max(|arg|, |target|)` holds. If you do not
+specify `eps`, `std::numeric_limits<FloatingPoint>::epsilon * 100`
+is used as the default.
+
+```cpp
+// Notice that WithinRel comparison is symmetric, unlike Approx's.
+REQUIRE_THAT(1.0, WithinRel(1.1, 0.1));
+REQUIRE_THAT(1.1, WithinRel(1.0, 0.1));
+// Notice that inifnity == infinity for WithinRel
+REQUIRE_THAT(INFINITY, WithinRel(INFINITY));
+```
+
+
+### WithinULP
+
+`WithinULP` creates a matcher that accepts floating point numbers that
+are no more than `maxUlpDiff`
+[ULPs](https://en.wikipedia.org/wiki/Unit_in_the_last_place)
+away from the `target` value. The short version of what this means
+is that there is no more than `maxUlpDiff - 1` representable floating
+point numbers between the argument for matching and the `target` value.
+
+When using the ULP matcher in Catch2, it is important to keep in mind
+that Catch2 interprets ULP distance slightly differently than
+e.g. `std::nextafter` does.
+
+Catch2's ULP calculation obeys these relations:
+ * `ulpDistance(-x, x) == 2 * ulpDistance(x, 0)`
+ * `ulpDistance(-0, 0) == 0` (due to the above)
+ * `ulpDistance(DBL_MAX, INFINITY) == 1`
+ * `ulpDistancE(NaN, x) == infinity`
+
+
+**Important**: The WithinULP matcher requires the platform to use the
+[IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) representation for
+floating point numbers.
+
+```cpp
+REQUIRE_THAT( -0.f, WithinULP( 0.f, 0 ) );
+```
+
+
+## `Approx`
+
+```
+#include <catch2/catch_approx.hpp>
+```
+
+**We strongly recommend against using `Approx` when writing new code.**
+You should be using floating point matchers instead.
+
+Catch2 provides one more way to handle floating point comparisons. It is
+`Approx`, a special type with overloaded comparison operators, that can
+be used in standard assertions, e.g.
+
+```cpp
+REQUIRE(0.99999 == Catch::Approx(1));
+```
+
+`Approx` supports four comparison operators, `==`, `!=`, `<=`, `>=`, and can
+also be used with strong typedefs over `double`s. It can be used for both
+relative and margin comparisons by using its three customization points.
+Note that the semantics of this is always that of an _or_, so if either
+the relative or absolute margin comparison passes, then the whole comparison
+passes.
+
+The downside to `Approx` is that it has a couple of issues that we cannot
+fix without breaking backwards compatibility. Because Catch2 also provides
+complete set of matchers that implement different floating point comparison
+methods, `Approx` is left as-is, is considered deprecated, and should
+not be used in new code.
+
+The issues are
+ * All internal computation is done in `double`s, leading to slightly
+ different results if the inputs were floats.
+ * `Approx`'s relative margin comparison is not symmetric. This means
+ that `Approx( 10 ).epsilon(0.1) != 11.1` but `Approx( 11.1 ).epsilon(0.1) == 10`.
+ * By default, `Approx` only uses relative margin comparison. This means
+ that `Approx(0) == X` only passes for `X == 0`.
+
+
+### Approx details
+
+If you still want/need to know more about `Approx`, read on.
+
+Catch2 provides a UDL for `Approx`; `_a`. It resides in the `Catch::literals`
+namespace, and can be used like this:
+
+```cpp
+using namespace Catch::literals;
+REQUIRE( performComputation() == 2.1_a );
+```
+
+`Approx` has three customization points for the comparison:
+
+* **epsilon** - epsilon sets the coefficient by which a result
+can differ from `Approx`'s value before it is rejected.
+_Defaults to `std::numeric_limits<float>::epsilon()*100`._
+
+```cpp
+Approx target = Approx(100).epsilon(0.01);
+100.0 == target; // Obviously true
+200.0 == target; // Obviously still false
+100.5 == target; // True, because we set target to allow up to 1% difference
+```
+
+
+* **margin** - margin sets the absolute value by which
+a result can differ from `Approx`'s value before it is rejected.
+_Defaults to `0.0`._
+
+```cpp
+Approx target = Approx(100).margin(5);
+100.0 == target; // Obviously true
+200.0 == target; // Obviously still false
+104.0 == target; // True, because we set target to allow absolute difference of at most 5
+```
+
+* **scale** - scale is used to change the magnitude of `Approx` for the relative check.
+_By default, set to `0.0`._
+
+Scale could be useful if the computation leading to the result worked
+on a different scale than is used by the results. Approx's scale is added
+to Approx's value when computing the allowed relative margin from the
+Approx's value.
+
+
+---
+
+[Home](Readme.md#top)
diff --git a/packages/Catch2/docs/configuration.md b/packages/Catch2/docs/configuration.md
index 9fd7f58b6d9e964ccf3d26ddb067a5f0889147fe..d6e159e529e159eaf8a736aff0dcf8732d691c34 100644
--- a/packages/Catch2/docs/configuration.md
+++ b/packages/Catch2/docs/configuration.md
@@ -15,11 +15,12 @@
[Enabling stringification](#enabling-stringification)<br>
[Disabling exceptions](#disabling-exceptions)<br>
[Overriding Catch's debug break (`-b`)](#overriding-catchs-debug-break--b)<br>
+[Static analysis support](#static-analysis-support)<br>
Catch2 is designed to "just work" as much as possible, and most of the
configuration options below are changed automatically during compilation,
according to the detected environment. However, this detection can also
-be overriden by users, using macros documented below, and/or CMake options
+be overridden by users, using macros documented below, and/or CMake options
with the same name.
@@ -98,13 +99,19 @@ is equivalent with the out-of-the-box experience.
## Bazel support
-When `CATCH_CONFIG_BAZEL_SUPPORT` is defined or when `BAZEL_TEST=1` (which is set by the Bazel inside of a test environment),
-Catch2 will register a `JUnit` reporter writing to a path pointed by `XML_OUTPUT_FILE` provided by Bazel.
+
+Compiling Catch2 with `CATCH_CONFIG_BAZEL_SUPPORT` force-enables Catch2's
+support for Bazel's environment variables (normally Catch2 looks for
+`BAZEL_TEST=1` env var first).
+
+This can be useful if you are using older versions of Bazel, that do not
+yet have `BAZEL_TEST` env var support.
> `CATCH_CONFIG_BAZEL_SUPPORT` was [introduced](https://github.com/catchorg/Catch2/pull/2399) in Catch2 3.0.1.
> `CATCH_CONFIG_BAZEL_SUPPORT` was [deprecated](https://github.com/catchorg/Catch2/pull/2459) in Catch2 3.1.0.
+
## C++11 toggles
CATCH_CONFIG_CPP11_TO_STRING // Use `std::to_string`
@@ -149,13 +156,20 @@ by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.
CATCH_CONFIG_USE_ASYNC // Force parallel statistical processing of samples during benchmarking
CATCH_CONFIG_ANDROID_LOGWRITE // Use android's logging system for debug output
CATCH_CONFIG_GLOBAL_NEXTAFTER // Use nextafter{,f,l} instead of std::nextafter
+ CATCH_CONFIG_GETENV // System has a working `getenv`
> [`CATCH_CONFIG_ANDROID_LOGWRITE`](https://github.com/catchorg/Catch2/issues/1743) and [`CATCH_CONFIG_GLOBAL_NEXTAFTER`](https://github.com/catchorg/Catch2/pull/1739) were introduced in Catch2 2.10.0
+> `CATCH_CONFIG_GETENV` was [introduced](https://github.com/catchorg/Catch2/pull/2562) in Catch2 3.2.0
+
Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API support.
`CATCH_CONFIG_POSIX_SIGNALS` is on by default, except when Catch is compiled under `Cygwin`, where it is disabled by default (but can be force-enabled by defining `CATCH_CONFIG_POSIX_SIGNALS`).
+`CATCH_CONFIG_GETENV` is on by default, except when Catch2 is compiled for
+platforms that lacks working `std::getenv` (currently Windows UWP and
+Playstation).
+
`CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's
CRT is used to check for memory leaks, and displays them after the tests
finish running. This option only works when linking against the default
@@ -251,6 +265,31 @@ The macro will be used as is, that is, `CATCH_BREAK_INTO_DEBUGGER();`
must compile and must break into debugger.
+## Static analysis support
+
+> Introduced in Catch2 X.Y.Z.
+
+Some parts of Catch2, e.g. `SECTION`s, can be hard for static analysis
+tools to reason about. Catch2 can change its internals to help static
+analysis tools reason about the tests.
+
+Catch2 automatically detects some static analysis tools (initial
+implementation checks for clang-tidy and Coverity), but you can override
+its detection (in either direction) via
+
+```
+CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT // force enables static analysis help
+CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT // force disables static analysis help
+```
+
+_As the name suggests, this is currently experimental, and thus we provide
+no backwards compatibility guarantees._
+
+**DO NOT ENABLE THIS FOR BUILDS YOU INTEND TO RUN.** The changed internals
+are not meant to be runnable, only "scannable".
+
+
+
---
[Home](Readme.md#top)
diff --git a/packages/Catch2/docs/contributing.md b/packages/Catch2/docs/contributing.md
index addeb5c9a44e7d1ad29e436a4b558d8dd3f3f960..d9f87fc1a138d92f9779317d1e9b1e99a341ef91 100644
--- a/packages/Catch2/docs/contributing.md
+++ b/packages/Catch2/docs/contributing.md
@@ -55,6 +55,15 @@ tests from `SelfTest` through a specific reporter and then compare the
generated output with a known good output ("Baseline"). By default, new
tests should be placed here.
+To configure a Catch2 build with just the basic tests, use the `basic-tests`
+preset, like so:
+
+```
+# Assuming you are in Catch2's root folder
+
+cmake -B basic-test-build -S . -DCMAKE_BUILD_TYPE=Debug --preset basic-tests
+```
+
However, not all tests can be written as plain unit tests. For example,
checking that Catch2 orders tests randomly when asked to, and that this
random ordering is subset-invariant, is better done as an integration
@@ -76,21 +85,23 @@ configuration and require separate compilation.
Finally, CMake config tests test that you set Catch2's compile-time
configuration options through CMake, using CMake options of the same name.
-None of these tests are enabled by default. To enable them, add
+These test categories can be enabled one by one, by passing
`-DCATCH_BUILD_EXAMPLES=ON`, `-DCATCH_BUILD_EXTRA_TESTS=ON`, and
-`-DCATCH_ENABLE_CONFIGURE_TESTS=ON` when configuration the CMake build.
+`-DCATCH_ENABLE_CONFIGURE_TESTS=ON` when configuring the build.
-Bringing this all together, the steps below should configure, build,
-and run all tests in the `Debug` compilation.
+Catch2 also provides a preset that promises to enable _all_ test types,
+`all-tests`.
+
+The snippet below will build & run all tests, in `Debug` compilation mode.
<!-- snippet: catch2-build-and-test -->
<a id='snippet-catch2-build-and-test'></a>
```sh
-# 1. Regenerate the amalgamated distribution
+# 1. Regenerate the amalgamated distribution (some tests are built against it)
./tools/scripts/generateAmalgamatedFiles.py
# 2. Configure the full test build
-cmake -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_BUILD_EXTRA_TESTS=ON
+cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests
# 3. Run the actual build
cmake --build debug-build
@@ -125,7 +136,7 @@ information that you will need for updating Catch2's documentation, and
possibly some generic advise as well.
-### Technicalities
+### Technicalities
First, the technicalities:
@@ -203,7 +214,7 @@ and so on.
Catch2 currently targets C++14 as the minimum supported C++ version.
Features from higher language versions should be used only sparingly,
-when the benefits from using them outweight the maintenance overhead.
+when the benefits from using them outweigh the maintenance overhead.
Example of good use of polyfilling features is our use of `conjunction`,
where if available we use `std::conjunction` and otherwise provide our
@@ -291,7 +302,7 @@ Specifically, every source file should start with the licence header:
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
- // (See accompanying file LICENSE_1_0.txt or copy at
+ // (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -303,6 +314,20 @@ be `CATCH_MATCHERS_FOO_HPP_INCLUDED`, for `catch_generators_bar.hpp`, the includ
guard should be `CATCH_GENERATORS_BAR_HPP_INCLUDED`, and so on.
+### Adding new `CATCH_CONFIG` option
+
+When adding new `CATCH_CONFIG` option, there are multiple places to edit:
+ * `CMake/CatchConfigOptions.cmake` - this is used to generate the
+ configuration options in CMake, so that CMake frontends know about them.
+ * `docs/configuration.md` - this is where the options are documented
+ * `src/catch2/catch_user_config.hpp.in` - this is template for generating
+ `catch_user_config.hpp` which contains the materialized configuration
+ * `BUILD.bazel` - Bazel does not have configuration support like CMake,
+ and all expansions need to be done manually
+ * other files as needed, e.g. `catch2/internal/catch_config_foo.hpp`
+ for the logic that guards the configuration
+
+
## CoC
This project has a [CoC](../CODE_OF_CONDUCT.md). Please adhere to it
diff --git a/packages/Catch2/docs/deprecations.md b/packages/Catch2/docs/deprecations.md
index 2c9bf5517bb342188c62c3909239acc8c45c7f7b..1fb79aaa0fc723d39ceb21513b0d1456e26c22dc 100644
--- a/packages/Catch2/docs/deprecations.md
+++ b/packages/Catch2/docs/deprecations.md
@@ -26,6 +26,15 @@ to accurately probe the environment for this information so the flag
where it will export `BAZEL_TEST=1` for purposes like the above. Catch2
will now instead inspect the environment instead of relying on build configuration.
+### `IEventLister::skipTest( TestCaseInfo const& testInfo )`
+
+This event (including implementations in derived classes such as `ReporterBase`)
+is deprecated and will be removed in the next major release. It is currently
+invoked for all test cases that are not going to be executed due to the test run
+being aborted (when using `--abort` or `--abortx`). It is however
+**NOT** invoked for test cases that are [explicitly skipped using the `SKIP`
+macro](skipping-passing-failing.md#top).
+
---
[Home](Readme.md#top)
diff --git a/packages/Catch2/docs/event-listeners.md b/packages/Catch2/docs/event-listeners.md
index 9b706948d1f5adf26ec3efe6072fba2b23a46f9b..71db3e183aaafcb2e82512da7b62f1b855b895fd 100644
--- a/packages/Catch2/docs/event-listeners.md
+++ b/packages/Catch2/docs/event-listeners.md
@@ -33,7 +33,7 @@ public:
CATCH_REGISTER_LISTENER(testRunListener)
```
-_Note that you should not use any assertion macros within a Listener!_
+_Note that you should not use any assertion macros within a Listener!_
[You can find the list of events that the listeners can react to on its
own page](reporter-events.md#top).
diff --git a/packages/Catch2/docs/faq.md b/packages/Catch2/docs/faq.md
index 81d8be680fa2af90df03b6a20abda6ca72106ed3..a7d0455a35c94e8dbb7e0f4eb37858747ed4b854 100644
--- a/packages/Catch2/docs/faq.md
+++ b/packages/Catch2/docs/faq.md
@@ -8,6 +8,9 @@
[What is Catch2's ABI stability policy?](#what-is-catch2s-abi-stability-policy)<br>
[What is Catch2's API stability policy?](#what-is-catch2s-api-stability-policy)<br>
[Does Catch2 support running tests in parallel?](#does-catch2-support-running-tests-in-parallel)<br>
+[Can I compile Catch2 into a dynamic library?](#can-i-compile-catch2-into-a-dynamic-library)<br>
+[What repeatability guarantees does Catch2 provide?](#what-repeatability-guarantees-does-catch2-provide)<br>
+
## How do I run global setup/teardown only if tests will be run?
@@ -24,8 +27,8 @@ depending on how often the cleanup needs to happen.
## Why cannot I derive from the built-in reporters?
-They are not made to be overriden, in that we do not attempt to maintain
-a consistent internal state if a member function is overriden, and by
+They are not made to be overridden, in that we do not attempt to maintain
+a consistent internal state if a member function is overridden, and by
forbidding users from using them as a base class, we can refactor them
as needed later.
@@ -58,6 +61,34 @@ runners easier. [See the relevant section in our page on best
practices](usage-tips.md#parallel-tests).
+## Can I compile Catch2 into a dynamic library?
+
+Yes, Catch2 supports the [standard CMake `BUILD_SHARED_LIBS`
+option](https://cmake.org/cmake/help/latest/variable/BUILD_SHARED_LIBS.html).
+However, the dynamic library support is provided as-is. Catch2 does not
+provide API export annotations, and so you can only use it as a dynamic
+library on platforms that default to public visibility, or with tooling
+support to force export Catch2's API.
+
+
+## What repeatability guarantees does Catch2 provide?
+
+There are two places where it is meaningful to talk about Catch2's
+repeatability guarantees without taking into account user-provided
+code. First one is in the test case shuffling, and the second one is
+the output from random generators.
+
+Test case shuffling is repeatable across different platforms since v2.12.0,
+and it is also generally repeatable across versions, but we might break
+it from time to time. E.g. we broke repeatability with previous versions
+in v2.13.4 so that test cases with similar names are shuffled better.
+
+Random generators currently rely on platform's stdlib, specifically
+the distributions from `<random>`. We thus provide no extra guarantee
+above what your platform does. **Important: `<random>`'s distributions
+are not specified to be repeatable across different platforms.**
+
+
---
[Home](Readme.md#top)
diff --git a/packages/Catch2/docs/generators.md b/packages/Catch2/docs/generators.md
index 7a865d4364a7c39340086edae8064c54a0dac842..097997521c09705cc549db61ad42705429bf42e9 100644
--- a/packages/Catch2/docs/generators.md
+++ b/packages/Catch2/docs/generators.md
@@ -134,7 +134,7 @@ type, making their usage much nicer. These are
* `map<T>(func, GeneratorWrapper<U>&&)` for `MapGenerator<T, U, Func>` (map `U` to `T`)
* `chunk(chunk-size, GeneratorWrapper<T>&&)` for `ChunkGenerator<T>`
* `random(IntegerOrFloat a, IntegerOrFloat b)` for `RandomIntegerGenerator` or `RandomFloatGenerator`
-* `range(Arithemtic start, Arithmetic end)` for `RangeGenerator<Arithmetic>` with a step size of `1`
+* `range(Arithmetic start, Arithmetic end)` for `RangeGenerator<Arithmetic>` with a step size of `1`
* `range(Arithmetic start, Arithmetic end, Arithmetic step)` for `RangeGenerator<Arithmetic>` with a custom step size
* `from_range(InputIterator from, InputIterator to)` for `IteratorGenerator<T>`
* `from_range(Container const&)` for `IteratorGenerator<T>`
@@ -205,15 +205,37 @@ struct IGenerator : GeneratorUntypedBase {
// Precondition:
// The generator is either freshly constructed or the last call to next() returned true
virtual T const& get() const = 0;
+
+ // Returns user-friendly string showing the current generator element
+ // Does not have to be overridden, IGenerator provides default implementation
+ virtual std::string stringifyImpl() const;
};
```
However, to be able to use your custom generator inside `GENERATE`, it
will need to be wrapped inside a `GeneratorWrapper<T>`.
`GeneratorWrapper<T>` is a value wrapper around a
-`std::unique_ptr<IGenerator<T>>`.
+`Catch::Detail::unique_ptr<IGenerator<T>>`.
For full example of implementing your own generator, look into Catch2's
examples, specifically
[Generators: Create your own generator](../examples/300-Gen-OwnGenerator.cpp).
+
+### Handling empty generators
+
+The generator interface assumes that a generator always has at least one
+element. This is not always true, e.g. if the generator depends on an external
+datafile, the file might be missing.
+
+There are two ways to handle this, depending on whether you want this
+to be an error or not.
+
+ * If empty generator **is** an error, throw an exception in constructor.
+ * If empty generator **is not** an error, use the [`SKIP`](skipping-passing-failing.md#skipping-test-cases-at-runtime) in constructor.
+
+
+
+---
+
+[Home](Readme.md#top)
diff --git a/packages/Catch2/docs/limitations.md b/packages/Catch2/docs/limitations.md
index 55c54738a6d66a3b621957886949732fbe9cc923..cc0ed05d1370d2c910c439da74944f228ce0af51 100644
--- a/packages/Catch2/docs/limitations.md
+++ b/packages/Catch2/docs/limitations.md
@@ -88,8 +88,8 @@ because only one thread passes the `REQUIRE` macro and this is not
REQUIRE(cnt == 16);
```
-Because C++11 provides the necessary tools to do this, we are planning
-to remove this limitation in the future.
+We currently do not plan to support thread-safe assertions.
+
### Process isolation in a test
Catch does not support running tests in isolated (forked) processes. While this might in the future, the fact that Windows does not support forking and only allows full-on process creation and the desire to keep code as similar as possible across platforms, mean that this is likely to take significant development time, that is not currently available.
@@ -99,7 +99,7 @@ Catch does not support running tests in isolated (forked) processes. While this
Catch2 keeps test execution in one process strictly serial, and there
are no plans to change this. If you find yourself with a test suite
-that takes too long to run and yo uwant to make it parallel, you have
+that takes too long to run and you want to make it parallel, you have
to run multiple processes side by side.
There are 2 basic ways to do that,
@@ -155,7 +155,7 @@ with expansion:
### Clang/G++ -- skipping leaf sections after an exception
-Some versions of `libc++` and `libstdc++` (or their runtimes) have a bug with `std::uncaught_exception()` getting stuck returning `true` after rethrow, even if there are no active exceptions. One such case is this snippet, which skipped the sections "a" and "b", when compiled against `libcxxrt` from master
+Some versions of `libc++` and `libstdc++` (or their runtimes) have a bug with `std::uncaught_exception()` getting stuck returning `true` after rethrow, even if there are no active exceptions. One such case is this snippet, which skipped the sections "a" and "b", when compiled against `libcxxrt` from the master branch
```cpp
#include <catch2/catch_test_macros.hpp>
@@ -171,7 +171,7 @@ TEST_CASE("b") {
}
```
-If you are seeing a problem like this, i.e. a weird test paths that trigger only under Clang with `libc++`, or only under very specific version of `libstdc++`, it is very likely you are seeing this. The only known workaround is to use a fixed version of your standard library.
+If you are seeing a problem like this, i.e. weird test paths that trigger only under Clang with `libc++`, or only under very specific version of `libstdc++`, it is very likely you are seeing this. The only known workaround is to use a fixed version of your standard library.
### libstdc++, `_GLIBCXX_DEBUG` macro and random ordering of tests
diff --git a/packages/Catch2/docs/matchers.md b/packages/Catch2/docs/matchers.md
index 0060bfd172307af534a7389eb684bffd3118d654..14c1589821d3ae82b145e67568e3655ebf35b45a 100644
--- a/packages/Catch2/docs/matchers.md
+++ b/packages/Catch2/docs/matchers.md
@@ -141,58 +141,26 @@ are a permutation of the ones in `some_vec`.
### Floating point matchers
-Catch2 provides 3 matchers that target floating point numbers. These
+Catch2 provides 4 matchers that target floating point numbers. These
are:
* `WithinAbs(double target, double margin)`,
* `WithinULP(FloatingPoint target, uint64_t maxUlpDiff)`, and
* `WithinRel(FloatingPoint target, FloatingPoint eps)`.
+* `IsNaN()`
> `WithinRel` matcher was introduced in Catch2 2.10.0
+> `IsNaN` matcher was introduced in Catch2 3.3.2.
-`WithinAbs` creates a matcher that accepts floating point numbers whose
-difference with `target` is less than the `margin`.
+The first three serve to compare two floating pointe numbers. For more
+details about how they work, read [the docs on comparing floating point
+numbers](comparing-floating-point-numbers.md#floating-point-matchers).
-`WithinULP` creates a matcher that accepts floating point numbers that
-are no more than `maxUlpDiff`
-[ULPs](https://en.wikipedia.org/wiki/Unit_in_the_last_place)
-away from the `target` value. The short version of what this means
-is that there is no more than `maxUlpDiff - 1` representeable floating
-point numbers between the argument for matching and the `target` value.
-
-**Important**: The WithinULP matcher requires the platform to use the
-[IEEE-754](https://en.wikipedia.org/wiki/IEEE_754) representation for
-floating point numbers.
-
-
-`WithinRel` creates a matcher that accepts floating point numbers that
-are _approximately equal_ with the `target` with tolerance of `eps.`
-Specifically, it matches if
-`|arg - target| <= eps * max(|arg|, |target|)` holds. If you do not
-specify `eps`, `std::numeric_limits<FloatingPoint>::epsilon * 100`
-is used as the default.
-
-
-In practice, you will often want to combine multiple of these matchers,
-together for an assertion, because all 3 options have edge cases where
-they behave differently than you would expect. As an example, under
-the `WithinRel` matcher, a `0.` only ever matches a `0.` (or `-0.`),
-regardless of the relative tolerance specified. Thus, if you want to
-handle numbers that are "close enough to 0 to be 0", you have to combine
-it with the `WithinAbs` matcher.
-
-For example, to check that our computation matches known good value
-within 0.1%, or is close enough (no different to 5 decimal places)
-to zero, we would write this assertion:
-```cpp
- REQUIRE_THAT( computation(input),
- Catch::Matchers::WithinRel(expected, 0.001)
- || Catch::Matchers::WithinAbs(0, 0.000001) );
-```
-
-
-> floating point matchers live in `catch2/matchers/catch_matchers_floating.hpp`
+`IsNaN` then does exactly what it says on the tin. It matches the input
+if it is a NaN (Not a Number). The advantage of using it over just plain
+`REQUIRE(std::isnan(x))`, is that if the check fails, with `REQUIRE` you
+won't see the value of `x`, but with `REQUIRE_THAT(x, IsNaN())`, you will.
### Miscellaneous matchers
@@ -224,20 +192,30 @@ The other miscellaneous matcher utility is exception matching.
#### Matching exceptions
-Catch2 provides an utility macro for asserting that an expression
+Catch2 provides a utility macro for asserting that an expression
throws exception of specific type, and that the exception has desired
properties. The macro is `REQUIRE_THROWS_MATCHES(expr, ExceptionType, Matcher)`.
> `REQUIRE_THROWS_MATCHES` macro lives in `catch2/matchers/catch_matchers.hpp`
-Catch2 currently provides only one matcher for exceptions,
-`Message(std::string message)`. `Message` checks that the exception's
+Catch2 currently provides two matchers for exceptions.
+These are:
+* `Message(std::string message)`.
+* `MessageMatches(Matcher matcher)`.
+
+> `MessageMatches` was [introduced](https://github.com/catchorg/Catch2/pull/2570) in Catch2 3.3.0
+
+`Message` checks that the exception's
message, as returned from `what` is exactly equal to `message`.
+`MessageMatches` applies the provided matcher on the exception's
+message, as returned from `what`. This is useful in conjunctions with the `std::string` matchers (e.g. `StartsWith`)
+
Example use:
```cpp
REQUIRE_THROWS_MATCHES(throwsDerivedException(), DerivedException, Message("DerivedException::what"));
+REQUIRE_THROWS_MATCHES(throwsDerivedException(), DerivedException, MessageMatches(StartsWith("DerivedException")));
```
Note that `DerivedException` in the example above has to derive from
@@ -259,11 +237,19 @@ definitions to handle generic range-like types. These are:
* `Contains(T&& target_element, Comparator = std::equal_to<>{})`
* `Contains(Matcher element_matcher)`
* `AllMatch(Matcher element_matcher)`
-* `NoneMatch(Matcher element_matcher)`
* `AnyMatch(Matcher element_matcher)`
-* `AllTrue()`
-* `NoneTrue()`
-* `AnyTrue()`
+* `NoneMatch(Matcher element_matcher)`
+* `AllTrue()`, `AnyTrue()`, `NoneTrue()`
+* `RangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
+* `UnorderedRangeEquals(TargetRangeLike&&, Comparator = std::equal_to<>{})`
+
+> `IsEmpty`, `SizeIs`, `Contains` were introduced in Catch2 3.0.1
+
+> `All/Any/NoneMatch` were introduced in Catch2 3.0.1
+
+> `All/Any/NoneTrue` were introduced in Catch2 3.1.0
+
+> `RangeEquals` and `UnorderedRangeEquals` matchers were [introduced](https://github.com/catchorg/Catch2/pull/2377) in Catch2 3.3.0
`IsEmpty` should be self-explanatory. It successfully matches objects
that are empty according to either `std::empty`, or ADL-found `empty`
@@ -282,14 +268,33 @@ in which case a range is accepted if any of its elements is accepted
by the provided matcher.
`AllMatch`, `NoneMatch`, and `AnyMatch` match ranges for which either
-all, none, or any of the contained elements matches the given matcher,
+all, none, or any of the contained elements matches the given matcher,
respectively.
`AllTrue`, `NoneTrue`, and `AnyTrue` match ranges for which either
-all, none, or any of the contained elements are `true`, respectively.
-It works for ranges of `bool`s and ranges of elements (explicitly)
+all, none, or any of the contained elements are `true`, respectively.
+It works for ranges of `bool`s and ranges of elements (explicitly)
convertible to `bool`.
+`RangeEquals` compares the range that the matcher is constructed with
+(the "target range") against the range to be tested, element-wise. The
+match succeeds if all elements from the two ranges compare equal (using
+`operator==` by default). The ranges do not need to be the same type,
+and the element types do not need to be the same, as long as they are
+comparable. (e.g. you may compare `std::vector<int>` to `std::array<char>`).
+
+`UnorderedRangeEquals` is similar to `RangeEquals`, but the order
+does not matter. For example "1, 2, 3" would match "3, 2, 1", but not
+"1, 1, 2, 3" As with `RangeEquals`, `UnorderedRangeEquals` compares
+the individual elements using using `operator==` by default.
+
+Both `RangeEquals` and `UnorderedRangeEquals` optionally accept a
+predicate which can be used to compare the containers element-wise.
+
+To check a container elementwise against a given matcher, use
+`AllMatch`.
+
+
## Writing custom matchers (old style)
The old style of writing matchers has been introduced back in Catch
@@ -368,7 +373,7 @@ style matchers arbitrarily.
To create a new-style matcher, you have to create your own type that
derives from `Catch::Matchers::MatcherGenericBase`. Your type has to
-also provide two methods, `bool match( ... ) const` and overriden
+also provide two methods, `bool match( ... ) const` and overridden
`std::string describe() const`.
Unlike with old-style matchers, there are no requirements on how
diff --git a/packages/Catch2/docs/migrate-v2-to-v3.md b/packages/Catch2/docs/migrate-v2-to-v3.md
index a9c2bb6300cf8e3525f5a5c4bece2642c3c715eb..84ed76904a1f156df846f61a42265214a0c13290 100644
--- a/packages/Catch2/docs/migrate-v2-to-v3.md
+++ b/packages/Catch2/docs/migrate-v2-to-v3.md
@@ -21,9 +21,10 @@ reduced by roughly 80%. The improved ease of maintenance also led to
various runtime performance improvements and the introduction of new features.
For details, look at [the release notes of 3.0.1](release-notes.md#301).
-_Note that we still provide one header + one TU distribution but do
-not consider it the primarily supported option. You should also expect
-that the compilation times will be worse if you use this option._
+_Note that we still provide one header + one translation unit (TU)
+distribution but do not consider it the primarily supported option. You
+should also expect that the compilation times will be worse if you use
+this option._
## How to migrate projects from v2 to v3
diff --git a/packages/Catch2/docs/opensource-users.md b/packages/Catch2/docs/opensource-users.md
index c65f71851a01a5b9573eee1b0b1686b9a1372351..a02d0b98e2453cb97b2bc765ee3f8df91f533186 100644
--- a/packages/Catch2/docs/opensource-users.md
+++ b/packages/Catch2/docs/opensource-users.md
@@ -72,7 +72,7 @@ A header-only template engine for modern C++.
A C++17 template header-only library for the abstraction of memory access patterns.
### [libcluon](https://github.com/chrberger/libcluon)
-A single-header-only library written in C++14 to glue distributed software components (UDP, TCP, shared memory) supporting natively Protobuf, LCM/ZCM, MsgPack, and JSON for dynamic message transformations in-between.
+A single-header-only library written in C++14 to glue distributed software components (UDP, TCP, shared memory) supporting natively Protobuf, LCM/ZCM, MsgPack, and JSON for dynamic message transformations in-between.
### [MNMLSTC Core](https://github.com/mnmlstc/core)
A small and easy to use C++11 library that adds a functionality set that will be available in C++14 and later, as well as some useful additions.
@@ -95,6 +95,9 @@ A C++ client library for Consul. Consul is a distributed tool for discovering an
### [Reactive-Extensions/ RxCpp](https://github.com/Reactive-Extensions/RxCpp)
A library of algorithms for values-distributed-in-time.
+### [SFML](https://github.com/SFML/SFML)
+Simple and Fast Multimedia Library.
+
### [SOCI](https://github.com/SOCI/soci)
The C++ Database Access Library.
@@ -110,6 +113,12 @@ A header-only TOML parser and serializer for modern C++.
### [Trompeloeil](https://github.com/rollbear/trompeloeil)
A thread-safe header-only mocking framework for C++14.
+### [wxWidgets](https://www.wxwidgets.org/)
+Cross-Platform C++ GUI Library.
+
+### [xmlwrapp](https://github.com/vslavik/xmlwrapp)
+C++ XML parsing library using libxml2.
+
## Applications & Tools
### [App Mesh](https://github.com/laoshanxi/app-mesh)
@@ -137,7 +146,7 @@ Newsbeuter is an open-source RSS/Atom feed reader for text terminals.
A 2D, Zombie, RPG game which is being made on our own engine.
### [raspigcd](https://github.com/pantadeusz/raspigcd)
-Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrolers (just RPi + Stepsticks).
+Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrollers (just RPi + Stepsticks).
### [SpECTRE](https://github.com/sxs-collaboration/spectre)
SpECTRE is a code for multi-scale, multi-physics problems in astrophysics and gravitational physics.
diff --git a/packages/Catch2/docs/release-notes.md b/packages/Catch2/docs/release-notes.md
index da2c598cebbaa352c1a3bc33804ae66ada3366ca..8b413b1560fbe2670a90cfb6cc29380e94009c8f 100644
--- a/packages/Catch2/docs/release-notes.md
+++ b/packages/Catch2/docs/release-notes.md
@@ -2,6 +2,12 @@
# Release notes
**Contents**<br>
+[3.3.2](#332)<br>
+[3.3.1](#331)<br>
+[3.3.0](#330)<br>
+[3.2.1](#321)<br>
+[3.2.0](#320)<br>
+[3.1.1](#311)<br>
[3.1.0](#310)<br>
[3.0.1](#301)<br>
[2.13.7](#2137)<br>
@@ -50,6 +56,143 @@
[Even Older versions](#even-older-versions)<br>
+
+## 3.3.2
+
+### Improvements
+* Further reduced allocations
+ * The compact, console, TAP and XML reporters perform less allocations in various cases
+ * Removed 1 allocation per entered `SECTION`/`TEST_CASE`.
+ * Removed 2 allocations per test case exit, if stdout/stderr is captured
+* Improved performance
+ * Section tracking is 10%-25% faster than in v3.3.0
+ * Assertion handling is 5%-10% faster than in v3.3.0
+ * Test case registration is 1%-2% faster than in v3.3.0
+ * Tiny speedup for registering listeners
+ * Tiny speedup for `CAPTURE`, `TEST_CASE_METHOD`, `METHOD_AS_TEST_CASE`, and `TEMPLATE_LIST_TEST_*` macros.
+* `Contains`, `RangeEquals` and `UnorderedRangeEquals` matchers now support ranges with iterator + sentinel pair
+* Added `IsNaN` matcher
+ * Unlike `REQUIRE(isnan(x))`, `REQUIRE_THAT(x, IsNaN())` shows you the value of `x`.
+* Suppressed `declared_but_not_referenced` warning for NVHPC (#2637)
+
+### Fixes
+* Fixed performance regression in section tracking introduced in v3.3.1
+ * Extreme cases would cause the tracking to run about 4x slower than in 3.3.0
+
+
+## 3.3.1
+
+### Improvements
+* Reduced allocations and improved performance
+ * The exact improvements are dependent on your usage of Catch2.
+ * For example running Catch2's SelfTest binary performs 8k less allocations.
+ * The main improvement comes from smarter handling of `SECTION`s, especially sibling `SECTION`s
+
+
+## 3.3.0
+
+### Improvements
+
+* Added `MessageMatches` exception matcher (#2570)
+* Added `RangeEquals` and `UnorderedRangeEquals` generic range matchers (#2377)
+* Added `SKIP` macro for skipping tests from within the test body (#2360)
+ * All built-in reporters have been extended to handle it properly, whether your custom reporter needs changes depends on how it was written
+ * `skipTest` reporter event **is unrelated** to this, and has been deprecated since it has practically no uses
+* Restored support for PPC Macs in the break-into-debugger functionality (#2619)
+* Made our warning suppression compatible with CUDA toolkit pre 11.5 (#2626)
+* Cleaned out some static analysis complaints
+
+
+### Fixes
+
+* Fixed macro redefinition warning when NVCC was reporting as MSVC (#2603)
+* Fixed throws in generator constructor causing the whole binary to abort (#2615)
+ * Now it just fails the test
+* Fixed missing transitive include with libstdc++13 (#2611)
+
+
+### Miscellaneous
+
+* Improved support for dynamic library build with non-MSVC compilers on Windows (#2630)
+* When used as a subproject, Catch2 keeps its generated header in a separate directory from the main project (#2604)
+
+
+
+## 3.2.1
+
+### Improvements
+* Fix the reworked decomposer to work with older (pre 9) GCC versions (#2571)
+ * **This required more significant changes to properly support C++20, there might be bugs.**
+
+
+## 3.2.0
+
+### Improvements
+* Catch2 now compiles on PlayStation (#2562)
+* Added `CATCH_CONFIG_GETENV` compile-time toggle (#2562)
+ * This toggle guards whether Catch2 calls `std::getenv` when reading env variables
+* Added support for more Bazel test environment variables
+ * `TESTBRIDGE_TEST_ONLY` is now supported (#2490)
+ * Sharding variables, `TEST_SHARD_INDEX`, `TEST_TOTAL_SHARDS`, `TEST_SHARD_STATUS_FILE`, are now all supported (#2491)
+* Bunch of small tweaks and improvements in reporters
+ * The TAP and SonarQube reporters output the used test filters
+ * The XML reporter now also reports the version of its output format
+ * The compact reporter now uses the same summary output as the console reporter (#878, #2554)
+* Added support for asserting on types that can only be compared with literal 0 (#2555)
+ * A canonical example is C++20's `std::*_ordering` types, which cannot be compared with an `int` variable, only `0`
+ * The support extends to any type with this property, not just the ones in stdlib
+ * This change imposes 2-3% slowdown on compiling files that are heavy on `REQUIRE` and friends
+ * **This required significant rewrite of decomposition, there might be bugs**
+* Simplified internals of matcher related macros
+ * This provides about ~2% speed up compiling files that are heavy on `REQUIRE_THAT` and friends
+
+
+### Fixes
+* Cleaned out some warnings and static analysis issues
+ * Suppressed `-Wcomma` warning rarely occurring in templated test cases (#2543)
+ * Constified implementation details in `INFO` (#2564)
+ * Made `MatcherGenericBase` copy constructor const (#2566)
+* Fixed serialization of test filters so the output roundtrips
+ * This means that e.g. `./tests/SelfTest "aaa bbb", [approx]` outputs `Filters: "aaa bbb",[approx]`
+
+
+### Miscellaneous
+* Catch2's build no longer leaks `-ffile-prefix-map` setting to dependees (#2533)
+
+
+
+## 3.1.1
+
+### Improvements
+* Added `Catch::getSeed` function that user code can call to retrieve current rng-seed
+* Better detection of compiler support for `-ffile-prefix-map` (#2517)
+* Catch2's shared libraries now have `SOVERSION` set (#2516)
+* `catch2/catch_all.hpp` convenience header no longer transitively includes `windows.h` (#2432, #2526)
+
+
+### Fixes
+* Fixed compilation on Universal Windows Platform
+* Fixed compilation on VxWorks (#2515)
+* Fixed compilation on Cygwin (#2540)
+* Remove unused variable in reporter registration (#2538)
+* Fixed some symbol visibility issues with dynamic library on Windows (#2527)
+* Suppressed `-Wuseless-cast` warnings in `REQUIRE_THROWS*` macros (#2520, #2521)
+ * This was triggered when the potentially throwing expression evaluates to `void`
+* Fixed "warning: storage class is not first" with `nvc++` (#2533)
+* Fixed handling of `DL_PATHS` argument to `catch_discover_tests` on MacOS (#2483)
+* Suppressed `*-avoid-c-arrays` clang-tidy warning in `TEMPLATE_TEST_CASE` (#2095, #2536)
+
+
+### Miscellaneous
+* Fixed CMake install step for Catch2 build as dynamic library (#2485)
+* Raised minimum CMake version to 3.10 (#2523)
+ * Expect the minimum CMake version to increase once more in next few releases.
+* Whole bunch of doc updates and fixes
+ * #1444, #2497, #2547, #2549, and more
+* Added support for building Catch2 with Meson (#2530, #2539)
+
+
+
## 3.1.0
### Improvements
@@ -374,7 +517,7 @@ v3 releases.
* The `SECTION`(s) before the `GENERATE` will not be run multiple times, the following ones will.
* Added `-D`/`--min-duration` command line flag (#1910)
* If a test takes longer to finish than the provided value, its name and duration will be printed.
- * This flag is overriden by setting `-d`/`--duration`.
+ * This flag is overridden by setting `-d`/`--duration`.
### Fixes
* `TAPReporter` no longer skips successful assertions (#1983)
@@ -415,7 +558,7 @@ v3 releases.
### Improvements
* `std::result_of` is not used if `std::invoke_result` is available (#1934)
* JUnit reporter writes out `status` attribute for tests (#1899)
-* Suppresed clang-tidy's `hicpp-vararg` warning (#1921)
+* Suppressed clang-tidy's `hicpp-vararg` warning (#1921)
* Catch2 was already suppressing the `cppcoreguidelines-pro-type-vararg` alias of the warning
@@ -442,7 +585,7 @@ v3 releases.
### Fixes
* Fixed computation of benchmarking column widths in ConsoleReporter (#1885, #1886)
* Suppressed clang-tidy's `cppcoreguidelines-pro-type-vararg` in assertions (#1901)
- * It was a false positive trigered by the new warning support workaround
+ * It was a false positive triggered by the new warning support workaround
* Fixed bug in test specification parser handling of OR'd patterns using escaping (#1905)
### Miscellaneous
@@ -779,7 +922,7 @@ v3 releases.
### Contrib
* `ParseAndAddCatchTests` has learned how to use `DISABLED` CTest property (#1452)
-* `ParseAndAddCatchTests` now works when there is a whitspace before the test name (#1493)
+* `ParseAndAddCatchTests` now works when there is a whitespace before the test name (#1493)
### Miscellaneous
diff --git a/packages/Catch2/docs/reporter-events.md b/packages/Catch2/docs/reporter-events.md
index 7adae53cab29785d5a61f7fa99c668e0868caa0a..015f67be4f174468f82e04f3ed32823a8ba1ed75 100644
--- a/packages/Catch2/docs/reporter-events.md
+++ b/packages/Catch2/docs/reporter-events.md
@@ -96,12 +96,12 @@ void assertionStarting( AssertionInfo const& assertionInfo );
void assertionEnded( AssertionStats const& assertionStats );
```
-`assertionStarting` is called after the expression is captured, but before
-the assertion expression is evaluated. This might seem like a minor
-distinction, but what it means is that if you have assertion like
-`REQUIRE( a + b == c + d )`, then what happens is that `a + b` and `c + d`
-are evaluated before `assertionStarting` is emitted, while the `==` is
-evaluated after the event.
+The `assertionStarting` event is emitted before the expression in the
+assertion is captured or evaluated and `assertionEnded` is emitted
+afterwards. This means that given assertion like `REQUIRE(a + b == c + d)`,
+Catch2 first emits `assertionStarting` event, then `a + b` and `c + d`
+are evaluated, then their results are captured, the comparison is evaluated,
+and then `assertionEnded` event is emitted.
## Benchmarking events
@@ -138,7 +138,7 @@ benchmarking itself fails.
> Introduced in Catch2 3.0.1.
Listings events are events that correspond to the test binary being
-invoked with `--list-foo` flag.
+invoked with `--list-foo` flag.
There are currently 3 listing events, one for reporters, one for tests,
and one for tags. Note that they are not exclusive to each other.
diff --git a/packages/Catch2/docs/skipping-passing-failing.md b/packages/Catch2/docs/skipping-passing-failing.md
new file mode 100644
index 0000000000000000000000000000000000000000..d866b418d1b572756e914e6c9d7da8ea12e6c0c1
--- /dev/null
+++ b/packages/Catch2/docs/skipping-passing-failing.md
@@ -0,0 +1,135 @@
+<a id="top"></a>
+# Explicitly skipping, passing, and failing tests at runtime
+
+## Skipping Test Cases at Runtime
+
+> [Introduced](https://github.com/catchorg/Catch2/pull/2360) in Catch2 3.3.0.
+
+In some situations it may not be possible to meaningfully execute a test case,
+for example when the system under test is missing certain hardware capabilities.
+If the required conditions can only be determined at runtime, it often
+doesn't make sense to consider such a test case as either passed or failed,
+because it simply can not run at all.
+
+To properly express such scenarios, Catch2 provides a way to explicitly
+_skip_ test cases, using the `SKIP` macro:
+
+```
+SKIP( [streamable expression] )
+```
+
+Example usage:
+
+```c++
+TEST_CASE("copy files between drives") {
+ if(getNumberOfHardDrives() < 2) {
+ SKIP("at least two hard drives required");
+ }
+ // ...
+}
+```
+
+This test case is then reported as _skipped_ instead of _passed_ or _failed_.
+
+The `SKIP` macro behaves similarly to an explicit [`FAIL`](#passing-and-failing-test-cases),
+in that it is the last expression that will be executed:
+
+```c++
+TEST_CASE("my test") {
+ printf("foo");
+ SKIP();
+ printf("bar"); // not printed
+}
+```
+
+However a failed assertion _before_ a `SKIP` still causes the entire
+test case to fail:
+
+```c++
+TEST_CASE("failing test") {
+ CHECK(1 == 2);
+ SKIP();
+}
+```
+
+### Interaction with Sections and Generators
+
+Sections, nested sections as well as specific outputs from [generators](generators.md#top)
+can all be individually skipped, with the rest executing as usual:
+
+```c++
+TEST_CASE("complex test case") {
+ int value = GENERATE(2, 4, 6);
+ SECTION("a") {
+ SECTION("a1") { CHECK(value < 8); }
+ SECTION("a2") {
+ if (value == 4) {
+ SKIP();
+ }
+ CHECK(value % 2 == 0);
+ }
+ }
+}
+```
+
+This test case will report 5 passing assertions; one for each of the three
+values in section `a1`, and then two in section `a2`, from values 2 and 4.
+
+Note that as soon as one section is skipped, the entire test case will
+be reported as _skipped_ (unless there is a failing assertion, in which
+case the test is handled as _failed_ instead).
+
+Note that if all test cases in a run are skipped, Catch2 returns a non-zero
+exit code, same as it does if no test cases have run. This behaviour can
+be overridden using the [--allow-running-no-tests](command-line.md#no-tests-override)
+flag.
+
+### `SKIP` inside generators
+
+You can also use the `SKIP` macro inside generator's constructor to handle
+cases where the generator is empty, but you do not want to fail the test
+case.
+
+
+## Passing and failing test cases
+
+Test cases can also be explicitly passed or failed, without the use of
+assertions, and with a specific message. This can be useful to handle
+complex preconditions/postconditions and give useful error messages
+when they fail.
+
+* `SUCCEED( [streamable expression] )`
+
+`SUCCEED` is morally equivalent with `INFO( [streamable expression] ); REQUIRE( true );`.
+Note that it does not stop further test execution, so it cannot be used
+to guard failing assertions from being executed.
+
+_In practice, `SUCCEED` is usually used as a test placeholder, to avoid
+[failing a test case due to missing assertions](command-line.md#warnings)._
+
+```cpp
+TEST_CASE( "SUCCEED showcase" ) {
+ int I = 1;
+ SUCCEED( "I is " << I );
+ // ... execution continues here ...
+}
+```
+
+* `FAIL( [streamable expression] )`
+
+`FAIL` is morally equivalent with `INFO( [streamable expression] ); REQUIRE( false );`.
+
+_In practice, `FAIL` is usually used to stop executing test that is currently
+known to be broken, but has to be fixed later._
+
+```cpp
+TEST_CASE( "FAIL showcase" ) {
+ FAIL( "This test case causes segfault, which breaks CI." );
+ // ... this will not be executed ...
+}
+```
+
+
+---
+
+[Home](Readme.md#top)
diff --git a/packages/Catch2/docs/test-cases-and-sections.md b/packages/Catch2/docs/test-cases-and-sections.md
index 613bbd14f307c884ea4512186aec3587fd770279..acebcc51d76419413b2e7a1fc6f873562d158585 100644
--- a/packages/Catch2/docs/test-cases-and-sections.md
+++ b/packages/Catch2/docs/test-cases-and-sections.md
@@ -25,7 +25,8 @@ _section description_ can be used to provide long form description
of a section while keeping the _section name_ short for use with the
[`-c` command line parameter](command-line.md#specify-the-section-to-run).
-**Test names must be unique within the Catch executable.**
+**The combination of test names and tags must be unique within the Catch2
+executable.**
For examples see the [Tutorial](tutorial.md#top)
@@ -68,7 +69,8 @@ All tag names beginning with non-alphanumeric characters are reserved by Catch.
* `[!nonportable]` - Indicates that behaviour may vary between platforms or compilers.
-* `[#<filename>]` - running with `-#` or `--filenames-as-tags` causes Catch to add the filename, prefixed with `#` (and with any extension stripped), as a tag to all contained tests, e.g. tests in testfile.cpp would all be tagged `[#testfile]`.
+* `[#<filename>]` - these tags are added to test cases when you run Catch2
+ with [`-#` or `--filenames-as-tags`](command-line.md#filenames-as-tags).
* `[@<alias>]` - tag aliases all begin with `@` (see below).
@@ -167,7 +169,11 @@ Other than the additional prefixes and the formatting in the console reporter th
In addition to `TEST_CASE`s, Catch2 also supports test cases parametrised
by types, in the form of `TEMPLATE_TEST_CASE`,
-`TEMPLATE_PRODUCT_TEST_CASE` and `TEMPLATE_LIST_TEST_CASE`.
+`TEMPLATE_PRODUCT_TEST_CASE` and `TEMPLATE_LIST_TEST_CASE`. These macros
+are defined in the `catch_template_test_macros.hpp` header, so compiling
+the code examples below also requires
+`#include <catch2/catch_template_test_macros.hpp>`.
+
* **TEMPLATE_TEST_CASE(** _test name_ , _tags_, _type1_, _type2_, ..., _typen_ **)**
@@ -289,7 +295,9 @@ TEMPLATE_LIST_TEST_CASE("Template test case with test types specified inside std
In addition to [type parametrised test cases](#type-parametrised-test-cases) Catch2 also supports
signature base parametrised test cases, in form of `TEMPLATE_TEST_CASE_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_SIG`.
These test cases have similar syntax like [type parametrised test cases](#type-parametrised-test-cases), with one
-additional positional argument which specifies the signature.
+additional positional argument which specifies the signature. These macros are defined in the
+`catch_template_test_macros.hpp` header, so compiling the code examples below also requires
+`#include <catch2/catch_template_test_macros.hpp>`.
### Signature
Signature has some strict rules for these tests cases to work properly:
diff --git a/packages/Catch2/docs/test-fixtures.md b/packages/Catch2/docs/test-fixtures.md
index e4747c269ca6941451214d00475983aa0ac7b68e..9c9eaa18c01b7db429da21c311d0565ac6677ab3 100644
--- a/packages/Catch2/docs/test-fixtures.md
+++ b/packages/Catch2/docs/test-fixtures.md
@@ -3,7 +3,7 @@
## Defining test fixtures
-Although Catch allows you to group tests together as sections within a test case, it can still be convenient, sometimes, to group them using a more traditional test fixture. Catch fully supports this too. You define the test fixture as a simple structure:
+Although Catch allows you to group tests together as [sections within a test case](test-cases-and-sections.md), it can still be convenient, sometimes, to group them using a more traditional test fixture. Catch fully supports this too. You define the test fixture as a simple structure:
```c++
class UniqueTestsFixture {
@@ -130,9 +130,9 @@ struct Template_Foo_2 {
};
TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(
- Template_Fixture_2,
- "A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds",
- "[class][template][product][nttp]",
+ Template_Fixture_2,
+ "A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds",
+ "[class][template][product][nttp]",
((typename T, size_t S), T, S),
(std::array, Template_Foo_2),
((int,2), (float,6))) {
diff --git a/packages/Catch2/docs/tutorial.md b/packages/Catch2/docs/tutorial.md
index 55a11714cafedaf6cb3900c949173e707b0f651e..342c7381812820a1b8a32955e83369a6f7f7ce96 100644
--- a/packages/Catch2/docs/tutorial.md
+++ b/packages/Catch2/docs/tutorial.md
@@ -13,9 +13,10 @@
## Getting Catch2
Ideally you should be using Catch2 through its [CMake integration](cmake-integration.md#top).
-Catch2 also provides pkg-config files and single TU distribution, but this
-documentation will assume you are using CMake. If you are using single-TU
-distribution instead, remember to replace the included header with `catch_amalgamated.hpp`.
+Catch2 also provides pkg-config files and two file (header + cpp)
+distribution, but this documentation will assume you are using CMake. If
+you are using the two file distribution instead, remember to replace
+the included header with `catch_amalgamated.hpp`.
## Writing tests
@@ -99,7 +100,7 @@ before we move on.
It accepts a boolean expression, and uses expression templates to
internally decompose it, so that it can be individually stringified
on test failure.
-
+
On the last point, note that there are more testing macros available,
because not all useful checks can be expressed as a simple boolean
expression. As an example, checking that an expression throws an exception
@@ -177,7 +178,7 @@ To continue on the vector example above, you could add a check that
}
```
-Another way to look at sections is that they are a way to define a tree
+Another way to look at sections is that they are a way to define a tree
of paths through the test. Each section represents a node, and the final
tree is walked in depth-first manner, with each path only visiting only
one leaf node.
diff --git a/packages/Catch2/docs/usage-tips.md b/packages/Catch2/docs/usage-tips.md
index 8e5c3df11a1f8f77a1fc27ab954de50996d0c53b..6be01ee632140179fe47642c733efca685178fb5 100644
--- a/packages/Catch2/docs/usage-tips.md
+++ b/packages/Catch2/docs/usage-tips.md
@@ -47,7 +47,7 @@ Catch2 also supports [splitting tests in a binary into multiple
shards](command-line.md#test-sharding). This can be used by any test
runner to run batches of tests in parallel. Do note that when selecting
on the number of shards, you should have more shards than there are cores,
-to avoid issues with long running tests getting accidentally grouped in
+to avoid issues with long-running tests getting accidentally grouped in
the same shard, and causing long-tailed execution time.
**Note that naively composing sharding and random ordering of tests will break.**
diff --git a/packages/Catch2/docs/why-catch.md b/packages/Catch2/docs/why-catch.md
index a4b8c2e2852ef987d6bec34cb034ccb585bb9ac9..2c0178ca5decacbc7bd5214a70e6e8bcc435d121 100644
--- a/packages/Catch2/docs/why-catch.md
+++ b/packages/Catch2/docs/why-catch.md
@@ -41,7 +41,7 @@ So what does Catch2 bring to the party that differentiates it from these? Apart
## Who else is using Catch2?
-A whole lot of people. According to the 2021 Jetbrains C++ ecosystem survey,
+A whole lot of people. According to the 2021 JetBrains C++ ecosystem survey,
about 11% of C++ programmers use Catch2 for unit testing, making it the
second most popular unit testing framework.
diff --git a/packages/Catch2/examples/302-Gen-Table.cpp b/packages/Catch2/examples/302-Gen-Table.cpp
index 74319518372296cac498e3ddc25fc954611f346f..97809889ce1d979fce6e817329c1967c5671b384 100644
--- a/packages/Catch2/examples/302-Gen-Table.cpp
+++ b/packages/Catch2/examples/302-Gen-Table.cpp
@@ -44,11 +44,11 @@ TEST_CASE("Table allows pre-computed test inputs and outputs", "[example][genera
/* Possible simplifications where less legacy toolchain support is needed:
*
- * - With libstdc++6 or newer, the make_tuple() calls can be ommitted
+ * - With libstdc++6 or newer, the make_tuple() calls can be omitted
* (technically C++17 but does not require -std in GCC/Clang). See
* https://stackoverflow.com/questions/12436586/tuple-vector-and-initializer-list
*
- * - In C++17 mode std::tie() and the preceding variable delcarations can be
+ * - In C++17 mode std::tie() and the preceding variable declarations can be
* replaced by structured bindings: auto [test_input, expected] = GENERATE(
* table<std::string, size_t>({ ...
*/
diff --git a/packages/Catch2/examples/CMakeLists.txt b/packages/Catch2/examples/CMakeLists.txt
index b934aa7cd7718f469fea9e4ba426347e199effc3..f993334180452305fb8c0e4f3356f1e1d07a3e33 100644
--- a/packages/Catch2/examples/CMakeLists.txt
+++ b/packages/Catch2/examples/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required( VERSION 3.5 )
+cmake_minimum_required( VERSION 3.10 )
project( Catch2Examples LANGUAGES CXX )
@@ -54,8 +54,6 @@ set(ALL_EXAMPLE_TARGETS
foreach( name ${ALL_EXAMPLE_TARGETS} )
target_link_libraries( ${name} Catch2 Catch2WithMain )
- set_property(TARGET ${name} PROPERTY CXX_STANDARD 14)
- set_property(TARGET ${name} PROPERTY CXX_EXTENSIONS OFF)
endforeach()
diff --git a/packages/Catch2/extras/Catch.cmake b/packages/Catch2/extras/Catch.cmake
index bc553591b25d9efbc460e7d0409fb9289c8d6200..b37b0bf6db6c64d1114b2b507dc0950f9bfa92af 100644
--- a/packages/Catch2/extras/Catch.cmake
+++ b/packages/Catch2/extras/Catch.cmake
@@ -35,8 +35,9 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
[TEST_LIST var]
[REPORTER reporter]
[OUTPUT_DIR dir]
- [OUTPUT_PREFIX prefix}
+ [OUTPUT_PREFIX prefix]
[OUTPUT_SUFFIX suffix]
+ [DISCOVERY_MODE <POST_BUILD|PRE_TEST>]
)
``catch_discover_tests`` sets up a post-build command on the test executable
@@ -123,14 +124,28 @@ same as the Catch name; see also ``TEST_PREFIX`` and ``TEST_SUFFIX``.
test executable and when the tests are executed themselves. This requires
cmake/ctest >= 3.22.
+ `DISCOVERY_MODE mode``
+ Provides control over when ``catch_discover_tests`` performs test discovery.
+ By default, ``POST_BUILD`` sets up a post-build command to perform test discovery
+ at build time. In certain scenarios, like cross-compiling, this ``POST_BUILD``
+ behavior is not desirable. By contrast, ``PRE_TEST`` delays test discovery until
+ just prior to test execution. This way test discovery occurs in the target environment
+ where the test has a better chance at finding appropriate runtime dependencies.
+
+ ``DISCOVERY_MODE`` defaults to the value of the
+ ``CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE`` variable if it is not passed when
+ calling ``catch_discover_tests``. This provides a mechanism for globally selecting
+ a preferred test discovery behavior without having to modify each call site.
+
#]=======================================================================]
#------------------------------------------------------------------------------
function(catch_discover_tests TARGET)
+
cmake_parse_arguments(
""
""
- "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX"
+ "TEST_PREFIX;TEST_SUFFIX;WORKING_DIRECTORY;TEST_LIST;REPORTER;OUTPUT_DIR;OUTPUT_PREFIX;OUTPUT_SUFFIX;DISCOVERY_MODE"
"TEST_SPEC;EXTRA_ARGS;PROPERTIES;DL_PATHS"
${ARGN}
)
@@ -141,12 +156,20 @@ function(catch_discover_tests TARGET)
if(NOT _TEST_LIST)
set(_TEST_LIST ${TARGET}_TESTS)
endif()
-
if (_DL_PATHS)
if(${CMAKE_VERSION} VERSION_LESS "3.22.0")
message(FATAL_ERROR "The DL_PATHS option requires at least cmake 3.22")
endif()
endif()
+ if(NOT _DISCOVERY_MODE)
+ if(NOT CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE)
+ set(CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE "POST_BUILD")
+ endif()
+ set(_DISCOVERY_MODE ${CMAKE_CATCH_DISCOVER_TESTS_DISCOVERY_MODE})
+ endif()
+ if (NOT _DISCOVERY_MODE MATCHES "^(POST_BUILD|PRE_TEST)$")
+ message(FATAL_ERROR "Unknown DISCOVERY_MODE: ${_DISCOVERY_MODE}")
+ endif()
## Generate a unique name based on the extra arguments
string(SHA1 args_hash "${_TEST_SPEC} ${_EXTRA_ARGS} ${_REPORTER} ${_OUTPUT_DIR} ${_OUTPUT_PREFIX} ${_OUTPUT_SUFFIX}")
@@ -159,39 +182,77 @@ function(catch_discover_tests TARGET)
TARGET ${TARGET}
PROPERTY CROSSCOMPILING_EMULATOR
)
- add_custom_command(
- TARGET ${TARGET} POST_BUILD
- BYPRODUCTS "${ctest_tests_file}"
- COMMAND "${CMAKE_COMMAND}"
- -D "TEST_TARGET=${TARGET}"
- -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
- -D "TEST_EXECUTOR=${crosscompiling_emulator}"
- -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
- -D "TEST_SPEC=${_TEST_SPEC}"
- -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
- -D "TEST_PROPERTIES=${_PROPERTIES}"
- -D "TEST_PREFIX=${_TEST_PREFIX}"
- -D "TEST_SUFFIX=${_TEST_SUFFIX}"
- -D "TEST_LIST=${_TEST_LIST}"
- -D "TEST_REPORTER=${_REPORTER}"
- -D "TEST_OUTPUT_DIR=${_OUTPUT_DIR}"
- -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
- -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
- -D "TEST_DL_PATHS=${_DL_PATHS}"
- -D "CTEST_FILE=${ctest_tests_file}"
- -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
- VERBATIM
- )
- file(WRITE "${ctest_include_file}"
- "if(EXISTS \"${ctest_tests_file}\")\n"
- " include(\"${ctest_tests_file}\")\n"
- "else()\n"
- " add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
- "endif()\n"
- )
+ if(_DISCOVERY_MODE STREQUAL "POST_BUILD")
+ add_custom_command(
+ TARGET ${TARGET} POST_BUILD
+ BYPRODUCTS "${ctest_tests_file}"
+ COMMAND "${CMAKE_COMMAND}"
+ -D "TEST_TARGET=${TARGET}"
+ -D "TEST_EXECUTABLE=$<TARGET_FILE:${TARGET}>"
+ -D "TEST_EXECUTOR=${crosscompiling_emulator}"
+ -D "TEST_WORKING_DIR=${_WORKING_DIRECTORY}"
+ -D "TEST_SPEC=${_TEST_SPEC}"
+ -D "TEST_EXTRA_ARGS=${_EXTRA_ARGS}"
+ -D "TEST_PROPERTIES=${_PROPERTIES}"
+ -D "TEST_PREFIX=${_TEST_PREFIX}"
+ -D "TEST_SUFFIX=${_TEST_SUFFIX}"
+ -D "TEST_LIST=${_TEST_LIST}"
+ -D "TEST_REPORTER=${_REPORTER}"
+ -D "TEST_OUTPUT_DIR=${_OUTPUT_DIR}"
+ -D "TEST_OUTPUT_PREFIX=${_OUTPUT_PREFIX}"
+ -D "TEST_OUTPUT_SUFFIX=${_OUTPUT_SUFFIX}"
+ -D "TEST_DL_PATHS=${_DL_PATHS}"
+ -D "CTEST_FILE=${ctest_tests_file}"
+ -P "${_CATCH_DISCOVER_TESTS_SCRIPT}"
+ VERBATIM
+ )
+
+ file(WRITE "${ctest_include_file}"
+ "if(EXISTS \"${ctest_tests_file}\")\n"
+ " include(\"${ctest_tests_file}\")\n"
+ "else()\n"
+ " add_test(${TARGET}_NOT_BUILT-${args_hash} ${TARGET}_NOT_BUILT-${args_hash})\n"
+ "endif()\n"
+ )
+
+ elseif(_DISCOVERY_MODE STREQUAL "PRE_TEST")
+
+ string(CONCAT ctest_include_content
+ "if(EXISTS \"$<TARGET_FILE:${TARGET}>\")" "\n"
+ " if(NOT EXISTS \"${ctest_tests_file}\" OR" "\n"
+ " NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"$<TARGET_FILE:${TARGET}>\" OR\n"
+ " NOT \"${ctest_tests_file}\" IS_NEWER_THAN \"\${CMAKE_CURRENT_LIST_FILE}\")\n"
+ " include(\"${_CATCH_DISCOVER_TESTS_SCRIPT}\")" "\n"
+ " catch_discover_tests_impl(" "\n"
+ " TEST_EXECUTABLE" " [==[" "$<TARGET_FILE:${TARGET}>" "]==]" "\n"
+ " TEST_EXECUTOR" " [==[" "${crosscompiling_emulator}" "]==]" "\n"
+ " TEST_WORKING_DIR" " [==[" "${_WORKING_DIRECTORY}" "]==]" "\n"
+ " TEST_SPEC" " [==[" "${_TEST_SPEC}" "]==]" "\n"
+ " TEST_EXTRA_ARGS" " [==[" "${_EXTRA_ARGS}" "]==]" "\n"
+ " TEST_PROPERTIES" " [==[" "${_PROPERTIES}" "]==]" "\n"
+ " TEST_PREFIX" " [==[" "${_TEST_PREFIX}" "]==]" "\n"
+ " TEST_SUFFIX" " [==[" "${_TEST_SUFFIX}" "]==]" "\n"
+ " TEST_LIST" " [==[" "${_TEST_LIST}" "]==]" "\n"
+ " TEST_REPORTER" " [==[" "${_REPORTER}" "]==]" "\n"
+ " TEST_OUTPUT_DIR" " [==[" "${_OUTPUT_DIR}" "]==]" "\n"
+ " TEST_OUTPUT_PREFIX" " [==[" "${_OUTPUT_PREFIX}" "]==]" "\n"
+ " TEST_OUTPUT_SUFFIX" " [==[" "${_OUTPUT_SUFFIX}" "]==]" "\n"
+ " CTEST_FILE" " [==[" "${ctest_tests_file}" "]==]" "\n"
+ " TEST_DL_PATHS" " [==[" "${_DL_PATHS}" "]==]" "\n"
+ " CTEST_FILE" " [==[" "${CTEST_FILE}" "]==]" "\n"
+ " )" "\n"
+ " endif()" "\n"
+ " include(\"${ctest_tests_file}\")" "\n"
+ "else()" "\n"
+ " add_test(${TARGET}_NOT_BUILT ${TARGET}_NOT_BUILT)" "\n"
+ "endif()" "\n"
+ )
+
+ file(GENERATE OUTPUT "${ctest_include_file}" CONTENT "${ctest_include_content}")
+ endif()
- if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
+ if(NOT ${CMAKE_VERSION} VERSION_LESS "3.10.0")
# Add discovered tests to directory TEST_INCLUDE_FILES
set_property(DIRECTORY
APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
@@ -204,9 +265,7 @@ function(catch_discover_tests TARGET)
PROPERTY TEST_INCLUDE_FILE "${ctest_include_file}"
)
else()
- message(FATAL_ERROR
- "Cannot set more than one TEST_INCLUDE_FILE"
- )
+ message(FATAL_ERROR "Cannot set more than one TEST_INCLUDE_FILE")
endif()
endif()
diff --git a/packages/Catch2/extras/CatchAddTests.cmake b/packages/Catch2/extras/CatchAddTests.cmake
index beec3aede51f3606ba931f7fe2c819af990aceef..91f79f3c5ba2ec2d9bad8eede892642dc110687f 100644
--- a/packages/Catch2/extras/CatchAddTests.cmake
+++ b/packages/Catch2/extras/CatchAddTests.cmake
@@ -1,28 +1,6 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
-set(prefix "${TEST_PREFIX}")
-set(suffix "${TEST_SUFFIX}")
-set(spec ${TEST_SPEC})
-set(extra_args ${TEST_EXTRA_ARGS})
-set(properties ${TEST_PROPERTIES})
-set(reporter ${TEST_REPORTER})
-set(output_dir ${TEST_OUTPUT_DIR})
-set(output_prefix ${TEST_OUTPUT_PREFIX})
-set(output_suffix ${TEST_OUTPUT_SUFFIX})
-set(dl_paths ${TEST_DL_PATHS})
-set(script)
-set(suite)
-set(tests)
-
-if(WIN32)
- set(dl_paths_variable_name PATH)
-elseif(APPLE)
- set(dl_paths_variable_name DYLD_LIBRARY_PATH)
-else()
- set(dl_paths_variable_name LD_LIBRARY_PATH)
-endif()
-
function(add_command NAME)
set(_args "")
# use ARGV* instead of ARGN, because ARGN splits arrays into multiple arguments
@@ -38,119 +16,172 @@ function(add_command NAME)
set(script "${script}${NAME}(${_args})\n" PARENT_SCOPE)
endfunction()
-# Run test executable to get list of available tests
-if(NOT EXISTS "${TEST_EXECUTABLE}")
- message(FATAL_ERROR
- "Specified test executable '${TEST_EXECUTABLE}' does not exist"
+function(catch_discover_tests_impl)
+
+ cmake_parse_arguments(
+ ""
+ ""
+ "TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_DL_PATHS;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
+ "TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR"
+ ${ARGN}
)
-endif()
-if(dl_paths)
- cmake_path(CONVERT "${dl_paths}" TO_NATIVE_PATH_LIST paths)
- set(ENV{${dl_paths_variable_name}} "${paths}")
-endif()
+ set(prefix "${_TEST_PREFIX}")
+ set(suffix "${_TEST_SUFFIX}")
+ set(spec ${_TEST_SPEC})
+ set(extra_args ${_TEST_EXTRA_ARGS})
+ set(properties ${_TEST_PROPERTIES})
+ set(reporter ${_TEST_REPORTER})
+ set(output_dir ${_TEST_OUTPUT_DIR})
+ set(output_prefix ${_TEST_OUTPUT_PREFIX})
+ set(output_suffix ${_TEST_OUTPUT_SUFFIX})
+ set(dl_paths ${_TEST_DL_PATHS})
+ set(script)
+ set(suite)
+ set(tests)
+
+ if(WIN32)
+ set(dl_paths_variable_name PATH)
+ elseif(APPLE)
+ set(dl_paths_variable_name DYLD_LIBRARY_PATH)
+ else()
+ set(dl_paths_variable_name LD_LIBRARY_PATH)
+ endif()
-execute_process(
- COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
- OUTPUT_VARIABLE output
- RESULT_VARIABLE result
- WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-)
-if(NOT ${result} EQUAL 0)
- message(FATAL_ERROR
- "Error running test executable '${TEST_EXECUTABLE}':\n"
- " Result: ${result}\n"
- " Output: ${output}\n"
- )
-endif()
+ # Run test executable to get list of available tests
+ if(NOT EXISTS "${_TEST_EXECUTABLE}")
+ message(FATAL_ERROR
+ "Specified test executable '${_TEST_EXECUTABLE}' does not exist"
+ )
+ endif()
-string(REPLACE "\n" ";" output "${output}")
-
-# Run test executable to get list of available reporters
-execute_process(
- COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} --list-reporters
- OUTPUT_VARIABLE reporters_output
- RESULT_VARIABLE reporters_result
- WORKING_DIRECTORY "${TEST_WORKING_DIR}"
-)
-if(NOT ${reporters_result} EQUAL 0)
- message(FATAL_ERROR
- "Error running test executable '${TEST_EXECUTABLE}':\n"
- " Result: ${reporters_result}\n"
- " Output: ${reporters_output}\n"
- )
-endif()
-string(FIND "${reporters_output}" "${reporter}" reporter_is_valid)
-if(reporter AND ${reporter_is_valid} EQUAL -1)
- message(FATAL_ERROR
- "\"${reporter}\" is not a valid reporter!\n"
- )
-endif()
+ if(dl_paths)
+ cmake_path(CONVERT "${dl_paths}" TO_NATIVE_PATH_LIST paths)
+ set(ENV{${dl_paths_variable_name}} "${paths}")
+ endif()
-# Prepare reporter
-if(reporter)
- set(reporter_arg "--reporter ${reporter}")
-endif()
+ execute_process(
+ COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} --list-tests --verbosity quiet
+ OUTPUT_VARIABLE output
+ RESULT_VARIABLE result
+ WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
+ )
+ if(NOT ${result} EQUAL 0)
+ message(FATAL_ERROR
+ "Error running test executable '${_TEST_EXECUTABLE}':\n"
+ " Result: ${result}\n"
+ " Output: ${output}\n"
+ )
+ endif()
-# Prepare output dir
-if(output_dir AND NOT IS_ABSOLUTE ${output_dir})
- set(output_dir "${TEST_WORKING_DIR}/${output_dir}")
- if(NOT EXISTS ${output_dir})
- file(MAKE_DIRECTORY ${output_dir})
+ string(REPLACE "\n" ";" output "${output}")
+
+ # Prepare reporter
+ if(reporter)
+ set(reporter_arg "--reporter ${reporter}")
+
+ # Run test executable to check whether reporter is available
+ # note that the use of --list-reporters is not the important part,
+ # we only want to check whether the execution succeeds with ${reporter_arg}
+ execute_process(
+ COMMAND ${TEST_EXECUTOR} "${TEST_EXECUTABLE}" ${spec} ${reporter_arg} --list-reporters
+ OUTPUT_VARIABLE reporter_check_output
+ RESULT_VARIABLE reporter_check_result
+ WORKING_DIRECTORY "${TEST_WORKING_DIR}"
+ )
+ if(${reporter_check_result} EQUAL 255)
+ message(FATAL_ERROR
+ "\"${reporter}\" is not a valid reporter!\n"
+ )
+ elseif(NOT ${reporter_check_result} EQUAL 0)
+ message(FATAL_ERROR
+ "Error running test executable '${TEST_EXECUTABLE}':\n"
+ " Result: ${reporter_check_result}\n"
+ " Output: ${reporter_check_output}\n"
+ )
+ endif()
endif()
-endif()
-if(dl_paths)
- foreach(path ${dl_paths})
- cmake_path(NATIVE_PATH path native_path)
- list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
- endforeach()
-endif()
+ # Prepare output dir
+ if(output_dir AND NOT IS_ABSOLUTE ${output_dir})
+ set(output_dir "${_TEST_WORKING_DIR}/${output_dir}")
+ if(NOT EXISTS ${output_dir})
+ file(MAKE_DIRECTORY ${output_dir})
+ endif()
+ endif()
-# Parse output
-foreach(line ${output})
- set(test ${line})
- # Escape characters in test case names that would be parsed by Catch2
- set(test_name ${test})
- foreach(char , [ ])
- string(REPLACE ${char} "\\${char}" test_name ${test_name})
- endforeach(char)
- # ...add output dir
- if(output_dir)
- string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean ${test_name})
- set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
+ if(dl_paths)
+ foreach(path ${dl_paths})
+ cmake_path(NATIVE_PATH path native_path)
+ list(APPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
+ endforeach()
endif()
-
- # ...and add to script
- add_command(add_test
- "${prefix}${test}${suffix}"
- ${TEST_EXECUTOR}
- "${TEST_EXECUTABLE}"
- "${test_name}"
- ${extra_args}
- "${reporter_arg}"
- "${output_dir_arg}"
- )
- add_command(set_tests_properties
- "${prefix}${test}${suffix}"
- PROPERTIES
- WORKING_DIRECTORY "${TEST_WORKING_DIR}"
- ${properties}
- )
- if(environment_modifications)
- add_command(set_tests_properties
- "${prefix}${test}${suffix}"
- PROPERTIES
- ENVIRONMENT_MODIFICATION "${environment_modifications}")
- endif()
+ # Parse output
+ foreach(line ${output})
+ set(test ${line})
+ # Escape characters in test case names that would be parsed by Catch2
+ set(test_name ${test})
+ foreach(char , [ ])
+ string(REPLACE ${char} "\\${char}" test_name ${test_name})
+ endforeach(char)
+ # ...add output dir
+ if(output_dir)
+ string(REGEX REPLACE "[^A-Za-z0-9_]" "_" test_name_clean ${test_name})
+ set(output_dir_arg "--out ${output_dir}/${output_prefix}${test_name_clean}${output_suffix}")
+ endif()
+
+ # ...and add to script
+ add_command(add_test
+ "${prefix}${test}${suffix}"
+ ${_TEST_EXECUTOR}
+ "${_TEST_EXECUTABLE}"
+ "${test_name}"
+ ${extra_args}
+ "${reporter_arg}"
+ "${output_dir_arg}"
+ )
+ add_command(set_tests_properties
+ "${prefix}${test}${suffix}"
+ PROPERTIES
+ WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
+ ${properties}
+ )
+
+ if(environment_modifications)
+ add_command(set_tests_properties
+ "${prefix}${test}${suffix}"
+ PROPERTIES
+ ENVIRONMENT_MODIFICATION "${environment_modifications}")
+ endif()
+
+ list(APPEND tests "${prefix}${test}${suffix}")
+ endforeach()
- list(APPEND tests "${prefix}${test}${suffix}")
-endforeach()
+ # Create a list of all discovered tests, which users may use to e.g. set
+ # properties on the tests
+ add_command(set ${_TEST_LIST} ${tests})
-# Create a list of all discovered tests, which users may use to e.g. set
-# properties on the tests
-add_command(set ${TEST_LIST} ${tests})
+ # Write CTest script
+ file(WRITE "${_CTEST_FILE}" "${script}")
+endfunction()
-# Write CTest script
-file(WRITE "${CTEST_FILE}" "${script}")
+if(CMAKE_SCRIPT_MODE_FILE)
+ catch_discover_tests_impl(
+ TEST_EXECUTABLE ${TEST_EXECUTABLE}
+ TEST_EXECUTOR ${TEST_EXECUTOR}
+ TEST_WORKING_DIR ${TEST_WORKING_DIR}
+ TEST_SPEC ${TEST_SPEC}
+ TEST_EXTRA_ARGS ${TEST_EXTRA_ARGS}
+ TEST_PROPERTIES ${TEST_PROPERTIES}
+ TEST_PREFIX ${TEST_PREFIX}
+ TEST_SUFFIX ${TEST_SUFFIX}
+ TEST_LIST ${TEST_LIST}
+ TEST_REPORTER ${TEST_REPORTER}
+ TEST_OUTPUT_DIR ${TEST_OUTPUT_DIR}
+ TEST_OUTPUT_PREFIX ${TEST_OUTPUT_PREFIX}
+ TEST_OUTPUT_SUFFIX ${TEST_OUTPUT_SUFFIX}
+ TEST_DL_PATHS ${TEST_DL_PATHS}
+ CTEST_FILE ${CTEST_FILE}
+ )
+endif()
diff --git a/packages/Catch2/extras/CatchShardTests.cmake b/packages/Catch2/extras/CatchShardTests.cmake
index d3b5e6fcf876afb12abba2843ece3786313520fe..68228f5a608a1fd95e9014648a9700a386c2c3a9 100644
--- a/packages/Catch2/extras/CatchShardTests.cmake
+++ b/packages/Catch2/extras/CatchShardTests.cmake
@@ -1,7 +1,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
@@ -46,7 +46,7 @@ function(catch_add_sharded_tests TARGET)
APPEND PROPERTY TEST_INCLUDE_FILES "${ctest_include_file}"
)
- set(shard_impl_script_file "${CMAKE_CURRENT_LIST_DIR}/CatchShardTestsImpl.cmake")
+ set(shard_impl_script_file "${_CATCH_DISCOVER_SHARD_TESTS_IMPL_SCRIPT}")
add_custom_command(
TARGET ${TARGET} POST_BUILD
@@ -64,3 +64,11 @@ function(catch_add_sharded_tests TARGET)
endfunction()
+
+
+###############################################################################
+
+set(_CATCH_DISCOVER_SHARD_TESTS_IMPL_SCRIPT
+ ${CMAKE_CURRENT_LIST_DIR}/CatchShardTestsImpl.cmake
+ CACHE INTERNAL "Catch2 full path to CatchShardTestsImpl.cmake helper file"
+)
diff --git a/packages/Catch2/extras/CatchShardTestsImpl.cmake b/packages/Catch2/extras/CatchShardTestsImpl.cmake
index d18dddef1642e54aba158416bb53202c692a1a1c..bb2fc3ef60dc8d4e64999d38d5bf508c89f53593 100644
--- a/packages/Catch2/extras/CatchShardTestsImpl.cmake
+++ b/packages/Catch2/extras/CatchShardTestsImpl.cmake
@@ -1,7 +1,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/extras/catch_amalgamated.cpp b/packages/Catch2/extras/catch_amalgamated.cpp
index ecda2301b3adc6e555f5a27358c0af698762b882..a81b1b6ae5f852305d8d7cfefee26317e1486357 100644
--- a/packages/Catch2/extras/catch_amalgamated.cpp
+++ b/packages/Catch2/extras/catch_amalgamated.cpp
@@ -1,12 +1,12 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
-// Catch v3.1.0
-// Generated: 2022-07-17 20:14:05.885021
+// Catch v3.3.2
+// Generated: 2023-02-26 10:28:48.270752
// ----------------------------------------------------------
// This file is an amalgamation of multiple different files.
// You probably shouldn't edit it directly.
@@ -15,6 +15,28 @@
#include "catch_amalgamated.hpp"
+#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+// We might end up with the define made globally through the compiler,
+// and we don't want to trigger warnings for this
+#if !defined(NOMINMAX)
+# define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN)
+# define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
namespace Catch {
@@ -406,9 +428,9 @@ namespace Catch {
return reconstructedExpression;
}
- AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+ AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
: m_info( info ),
- m_resultData( data )
+ m_resultData( CATCH_MOVE(data) )
{}
// Result was a success
@@ -447,16 +469,15 @@ namespace Catch {
}
std::string AssertionResult::getExpressionInMacro() const {
- std::string expr;
- if( m_info.macroName.empty() )
- expr = static_cast<std::string>(m_info.capturedExpression);
- else {
- expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
- expr += m_info.macroName;
- expr += "( ";
- expr += m_info.capturedExpression;
- expr += " )";
+ if ( m_info.macroName.empty() ) {
+ return static_cast<std::string>( m_info.capturedExpression );
}
+ std::string expr;
+ expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+ expr += m_info.macroName;
+ expr += "( ";
+ expr += m_info.capturedExpression;
+ expr += " )";
return expr;
}
@@ -486,29 +507,73 @@ namespace Catch {
-namespace {
- bool provideBazelReporterOutput() {
-#ifdef CATCH_CONFIG_BAZEL_SUPPORT
- return true;
+#include <fstream>
+
+namespace Catch {
+
+ namespace {
+ static bool enableBazelEnvSupport() {
+#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
+ return true;
#else
+ return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
+#endif
+ }
-# if defined( _MSC_VER )
- // On Windows getenv throws a warning as there is no input validation,
- // since the switch is hardcoded, this should not be an issue.
-# pragma warning( push )
-# pragma warning( disable : 4996 )
-# endif
+ struct bazelShardingOptions {
+ unsigned int shardIndex, shardCount;
+ std::string shardFilePath;
+ };
- return std::getenv( "BAZEL_TEST" ) != nullptr;
+ static Optional<bazelShardingOptions> readBazelShardingOptions() {
+ const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
+ const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
+ const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
+
+
+ const bool has_all =
+ bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
+ if ( !has_all ) {
+ // We provide nice warning message if the input is
+ // misconfigured.
+ auto warn = []( const char* env_var ) {
+ Catch::cerr()
+ << "Warning: Bazel shard configuration is missing '"
+ << env_var << "'. Shard configuration is skipped.\n";
+ };
+ if ( !bazelShardIndex ) {
+ warn( "TEST_SHARD_INDEX" );
+ }
+ if ( !bazelShardTotal ) {
+ warn( "TEST_TOTAL_SHARDS" );
+ }
+ if ( !bazelShardInfoFile ) {
+ warn( "TEST_SHARD_STATUS_FILE" );
+ }
+ return {};
+ }
-# if defined( _MSC_VER )
-# pragma warning( pop )
-# endif
-#endif
- }
-}
+ auto shardIndex = parseUInt( bazelShardIndex );
+ if ( !shardIndex ) {
+ Catch::cerr()
+ << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
+ << "') as unsigned int.\n";
+ return {};
+ }
+ auto shardTotal = parseUInt( bazelShardTotal );
+ if ( !shardTotal ) {
+ Catch::cerr()
+ << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
+ << bazelShardTotal << "') as unsigned int.\n";
+ return {};
+ }
+
+ return bazelShardingOptions{
+ *shardIndex, *shardTotal, bazelShardInfoFile };
+
+ }
+ } // end namespace
-namespace Catch {
bool operator==( ProcessedReporterSpec const& lhs,
ProcessedReporterSpec const& rhs ) {
@@ -531,17 +596,6 @@ namespace Catch {
elem = trim(elem);
}
-
- TestSpecParser parser(ITagAliasRegistry::get());
- if (!m_data.testsOrTags.empty()) {
- m_hasTestFilters = true;
- for (auto const& testOrTags : m_data.testsOrTags) {
- parser.parse(testOrTags);
- }
- }
- m_testSpec = parser.testSpec();
-
-
// Insert the default reporter if user hasn't asked for a specfic one
if ( m_data.reporterSpecifications.empty() ) {
m_data.reporterSpecifications.push_back( {
@@ -554,27 +608,20 @@ namespace Catch {
} );
}
- if(provideBazelReporterOutput()){
- // Register a JUnit reporter for Bazel. Bazel sets an environment
- // variable with the path to XML output. If this file is written to
- // during test, Bazel will not generate a default XML output.
- // This allows the XML output file to contain higher level of detail
- // than what is possible otherwise.
-# if defined( _MSC_VER )
- // On Windows getenv throws a warning as there is no input validation,
- // since the key is hardcoded, this should not be an issue.
-# pragma warning( push )
-# pragma warning( disable : 4996 )
-# endif
- const auto bazelOutputFilePtr = std::getenv( "XML_OUTPUT_FILE" );
-# if defined( _MSC_VER )
-# pragma warning( pop )
-# endif
- if ( bazelOutputFilePtr != nullptr ) {
- m_data.reporterSpecifications.push_back(
- { "junit", std::string( bazelOutputFilePtr ), {}, {} } );
+ if ( enableBazelEnvSupport() ) {
+ readBazelEnvVars();
+ }
+
+ // Bazel support can modify the test specs, so parsing has to happen
+ // after reading Bazel env vars.
+ TestSpecParser parser( ITagAliasRegistry::get() );
+ if ( !m_data.testsOrTags.empty() ) {
+ m_hasTestFilters = true;
+ for ( auto const& testOrTags : m_data.testsOrTags ) {
+ parser.parse( testOrTags );
}
- }
+ }
+ m_testSpec = parser.testSpec();
// We now fixup the reporter specs to handle default output spec,
@@ -655,10 +702,53 @@ namespace Catch {
unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+ void Config::readBazelEnvVars() {
+ // Register a JUnit reporter for Bazel. Bazel sets an environment
+ // variable with the path to XML output. If this file is written to
+ // during test, Bazel will not generate a default XML output.
+ // This allows the XML output file to contain higher level of detail
+ // than what is possible otherwise.
+ const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
+
+ if ( bazelOutputFile ) {
+ m_data.reporterSpecifications.push_back(
+ { "junit", std::string( bazelOutputFile ), {}, {} } );
+ }
+
+ const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
+ if ( bazelTestSpec ) {
+ // Presumably the test spec from environment should overwrite
+ // the one we got from CLI (if we got any)
+ m_data.testsOrTags.clear();
+ m_data.testsOrTags.push_back( bazelTestSpec );
+ }
+
+ const auto bazelShardOptions = readBazelShardingOptions();
+ if ( bazelShardOptions ) {
+ std::ofstream f( bazelShardOptions->shardFilePath,
+ std::ios_base::out | std::ios_base::trunc );
+ if ( f.is_open() ) {
+ f << "";
+ m_data.shardIndex = bazelShardOptions->shardIndex;
+ m_data.shardCount = bazelShardOptions->shardCount;
+ }
+ }
+ }
+
} // end namespace Catch
+
+
+namespace Catch {
+ std::uint32_t getSeed() {
+ return getCurrentContext().getConfig()->rngSeed();
+ }
+}
+
+
+
#include <cassert>
#include <stack>
@@ -667,8 +757,8 @@ namespace Catch {
////////////////////////////////////////////////////////////////////////////
- ScopedMessage::ScopedMessage( MessageBuilder const& builder ):
- m_info( builder.m_info ) {
+ ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
+ m_info( CATCH_MOVE(builder.m_info) ) {
m_info.message = builder.m_stream.str();
getResultCapture().pushScopedMessage( m_info );
}
@@ -882,7 +972,6 @@ namespace Catch {
multi->addListener(listener->create(config));
}
- std::size_t reporterIdx = 0;
for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
multi->addReporter( createReporter(
reporterSpec.name,
@@ -890,7 +979,6 @@ namespace Catch {
makeStream( reporterSpec.outputFilename ),
reporterSpec.colourMode,
reporterSpec.customOptions ) ) );
- reporterIdx++;
}
return multi;
@@ -1164,6 +1252,12 @@ namespace Catch {
return 2;
}
+ if ( totals.testCases.total() > 0 &&
+ totals.testCases.total() == totals.testCases.skipped
+ && !m_config->zeroTestsCountAsSuccess() ) {
+ return 4;
+ }
+
// Note that on unices only the lower 8 bits are usually used, clamping
// the return value to 255 prevents false negative when some multiple
// of 256 tests has failed
@@ -1438,6 +1532,7 @@ namespace Catch {
#include <algorithm>
#include <string>
#include <vector>
+#include <ostream>
namespace Catch {
@@ -1461,6 +1556,10 @@ namespace Catch {
return m_wildcardPattern.matches( testCase.name );
}
+ void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
+ out << '"' << name() << '"';
+ }
+
TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
: Pattern( filterString )
@@ -1473,6 +1572,10 @@ namespace Catch {
Tag( m_tag ) ) != end( testCase.tags );
}
+ void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
+ out << name();
+ }
+
bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
bool should_use = !testCase.isHidden();
for (auto const& pattern : m_required) {
@@ -1489,18 +1592,31 @@ namespace Catch {
return should_use;
}
- std::string TestSpec::Filter::name() const {
- std::string name;
- for (auto const& p : m_required) {
- name += p->name();
+ void TestSpec::Filter::serializeTo( std::ostream& out ) const {
+ bool first = true;
+ for ( auto const& pattern : m_required ) {
+ if ( !first ) {
+ out << ' ';
+ }
+ out << *pattern;
+ first = false;
}
- for (auto const& p : m_forbidden) {
- name += p->name();
+ for ( auto const& pattern : m_forbidden ) {
+ if ( !first ) {
+ out << ' ';
+ }
+ out << *pattern;
+ first = false;
}
- return name;
}
+ std::string TestSpec::extractFilterName( Filter const& filter ) {
+ Catch::ReusableStringStream sstr;
+ sstr << filter;
+ return sstr.str();
+ }
+
bool TestSpec::hasFilters() const {
return !m_filters.empty();
}
@@ -1517,7 +1633,7 @@ namespace Catch {
for( auto const& test : testCases )
if( isThrowSafe( test, config ) && filter.matches( test.getTestCaseInfo() ) )
currentMatches.emplace_back( &test );
- return FilterMatch{ filter.name(), currentMatches };
+ return FilterMatch{ extractFilterName(filter), currentMatches };
} );
return matches;
}
@@ -1526,6 +1642,17 @@ namespace Catch {
return m_invalidSpecs;
}
+ void TestSpec::serializeTo( std::ostream& out ) const {
+ bool first = true;
+ for ( auto const& filter : m_filters ) {
+ if ( !first ) {
+ out << ',';
+ }
+ out << filter;
+ first = false;
+ }
+ }
+
}
@@ -1813,6 +1940,7 @@ namespace Catch {
diff.passed = passed - other.passed;
diff.failed = failed - other.failed;
diff.failedButOk = failedButOk - other.failedButOk;
+ diff.skipped = skipped - other.skipped;
return diff;
}
@@ -1820,14 +1948,15 @@ namespace Catch {
passed += other.passed;
failed += other.failed;
failedButOk += other.failedButOk;
+ skipped += other.skipped;
return *this;
}
std::uint64_t Counts::total() const {
- return passed + failed + failedButOk;
+ return passed + failed + failedButOk + skipped;
}
bool Counts::allPassed() const {
- return failed == 0 && failedButOk == 0;
+ return failed == 0 && failedButOk == 0 && skipped == 0;
}
bool Counts::allOk() const {
return failed == 0;
@@ -1852,6 +1981,8 @@ namespace Catch {
++diff.testCases.failed;
else if( diff.assertions.failedButOk > 0 )
++diff.testCases.failedButOk;
+ else if ( diff.assertions.skipped > 0 )
+ ++ diff.testCases.skipped;
else
++diff.testCases.passed;
return diff;
@@ -1890,7 +2021,7 @@ namespace Catch {
}
Version const& libraryVersion() {
- static Version version( 3, 1, 0, "", 0 );
+ static Version version( 3, 3, 2, "", 0 );
return version;
}
@@ -1926,10 +2057,17 @@ namespace Detail {
GeneratorUntypedBase::~GeneratorUntypedBase() = default;
- auto acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+ IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
}
+ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ GeneratorBasePtr&& generator ) {
+ return getResultCapture().createGeneratorTracker(
+ generatorName, lineInfo, CATCH_MOVE( generator ) );
+ }
+
} // namespace Generators
} // namespace Catch
@@ -2040,18 +2178,17 @@ namespace Catch {
// Copy message into messages list.
// !TBD This should have been done earlier, somewhere
MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
- builder << assertionResult.getMessage();
- builder.m_info.message = builder.m_stream.str();
+ builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
- infoMessages.push_back( builder.m_info );
+ infoMessages.push_back( CATCH_MOVE(builder.m_info) );
}
}
- SectionStats::SectionStats( SectionInfo const& _sectionInfo,
+ SectionStats::SectionStats( SectionInfo&& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
- : sectionInfo( _sectionInfo ),
+ : sectionInfo( CATCH_MOVE(_sectionInfo) ),
assertions( _assertions ),
durationInSeconds( _durationInSeconds ),
missingAssertions( _missingAssertions )
@@ -2060,13 +2197,13 @@ namespace Catch {
TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
- std::string const& _stdOut,
- std::string const& _stdErr,
+ std::string&& _stdOut,
+ std::string&& _stdErr,
bool _aborting )
: testInfo( &_testInfo ),
totals( _totals ),
- stdOut( _stdOut ),
- stdErr( _stdErr ),
+ stdOut( CATCH_MOVE(_stdOut) ),
+ stdErr( CATCH_MOVE(_stdErr) ),
aborting( _aborting )
{}
@@ -2141,10 +2278,13 @@ namespace Catch {
CATCH_BREAK_INTO_DEBUGGER();
}
if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
- throw Catch::TestFailureException();
+ throw_test_failure_exception();
+ }
+ if ( m_reaction.shouldSkip ) {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+ throw Catch::TestSkipException();
#else
- CATCH_ERROR( "Test failure requires aborting test!" );
+ CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
#endif
}
}
@@ -2173,8 +2313,8 @@ namespace Catch {
// This is the overload that takes a string and infers the Equals matcher from it
// The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
- void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString ) {
- handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
+ handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
}
} // namespace Catch
@@ -2710,23 +2850,14 @@ namespace Catch {
return ParserResult::ok(ParseResultType::Matched);
}
- CATCH_TRY {
- std::size_t parsedTo = 0;
- unsigned long parsedSeed = std::stoul(seed, &parsedTo, 0);
- if (parsedTo != seed.size()) {
- return ParserResult::runtimeError("Could not parse '" + seed + "' as seed");
- }
-
- // TODO: Ideally we could parse unsigned int directly,
- // but the stdlib doesn't provide helper for that
- // type. After this is refactored to use fixed size
- // type, we should check the parsed value is in range
- // of the underlying type.
- config.rngSeed = static_cast<unsigned int>(parsedSeed);
- return ParserResult::ok(ParseResultType::Matched);
- } CATCH_CATCH_ANON(std::exception const&) {
- return ParserResult::runtimeError("Could not parse '" + seed + "' as seed");
+ // TODO: ideally we should be parsing uint32_t directly
+ // fix this later when we add new parse overload
+ auto parsedSeed = parseUInt( seed, 0 );
+ if ( !parsedSeed ) {
+ return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
}
+ config.rngSeed = *parsedSeed;
+ return ParserResult::ok( ParseResultType::Matched );
};
auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
@@ -2818,42 +2949,29 @@ namespace Catch {
return ParserResult::ok( ParseResultType::Matched );
};
auto const setShardCount = [&]( std::string const& shardCount ) {
- CATCH_TRY{
- std::size_t parsedTo = 0;
- int64_t parsedCount = std::stoll(shardCount, &parsedTo, 0);
- if (parsedTo != shardCount.size()) {
- return ParserResult::runtimeError("Could not parse '" + shardCount + "' as shard count");
- }
- if (parsedCount <= 0) {
- return ParserResult::runtimeError("Shard count must be a positive number");
- }
-
- config.shardCount = static_cast<unsigned int>(parsedCount);
- return ParserResult::ok(ParseResultType::Matched);
- } CATCH_CATCH_ANON(std::exception const&) {
- return ParserResult::runtimeError("Could not parse '" + shardCount + "' as shard count");
+ auto parsedCount = parseUInt( shardCount );
+ if ( !parsedCount ) {
+ return ParserResult::runtimeError(
+ "Could not parse '" + shardCount + "' as shard count" );
+ }
+ if ( *parsedCount == 0 ) {
+ return ParserResult::runtimeError(
+ "Shard count must be positive" );
}
+ config.shardCount = *parsedCount;
+ return ParserResult::ok( ParseResultType::Matched );
};
auto const setShardIndex = [&](std::string const& shardIndex) {
- CATCH_TRY{
- std::size_t parsedTo = 0;
- int64_t parsedIndex = std::stoll(shardIndex, &parsedTo, 0);
- if (parsedTo != shardIndex.size()) {
- return ParserResult::runtimeError("Could not parse '" + shardIndex + "' as shard index");
- }
- if (parsedIndex < 0) {
- return ParserResult::runtimeError("Shard index must be a non-negative number");
- }
-
- config.shardIndex = static_cast<unsigned int>(parsedIndex);
- return ParserResult::ok(ParseResultType::Matched);
- } CATCH_CATCH_ANON(std::exception const&) {
- return ParserResult::runtimeError("Could not parse '" + shardIndex + "' as shard index");
+ auto parsedIndex = parseUInt( shardIndex );
+ if ( !parsedIndex ) {
+ return ParserResult::runtimeError(
+ "Could not parse '" + shardIndex + "' as shard index" );
}
+ config.shardIndex = *parsedIndex;
+ return ParserResult::ok( ParseResultType::Matched );
};
-
auto cli
= ExeName( config.processName )
| Help( config.showHelp )
@@ -3595,6 +3713,9 @@ namespace Catch {
catch( TestFailureException& ) {
std::rethrow_exception(std::current_exception());
}
+ catch( TestSkipException& ) {
+ std::rethrow_exception(std::current_exception());
+ }
catch( std::exception const& ex ) {
return ex.what();
}
@@ -3891,6 +4012,35 @@ namespace Catch {
+
+#include <cstdlib>
+
+namespace Catch {
+ namespace Detail {
+
+#if !defined (CATCH_CONFIG_GETENV)
+ char const* getEnv( char const* ) { return nullptr; }
+#else
+
+ char const* getEnv( char const* varName ) {
+# if defined( _MSC_VER )
+# pragma warning( push )
+# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
+# endif
+
+ return std::getenv( varName );
+
+# if defined( _MSC_VER )
+# pragma warning( pop )
+# endif
+ }
+#endif
+} // namespace Detail
+} // namespace Catch
+
+
+
+
#include <cstdio>
#include <fstream>
#include <sstream>
@@ -3957,6 +4107,7 @@ namespace Detail {
FileStream( std::string const& filename ) {
m_ofs.open( filename.c_str() );
CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
+ m_ofs << std::unitbuf;
}
~FileStream() override = default;
public: // IStream
@@ -4383,6 +4534,50 @@ namespace Catch {
+#include <limits>
+#include <stdexcept>
+
+namespace Catch {
+
+ Optional<unsigned int> parseUInt(std::string const& input, int base) {
+ auto trimmed = trim( input );
+ // std::stoull is annoying and accepts numbers starting with '-',
+ // it just negates them into unsigned int
+ if ( trimmed.empty() || trimmed[0] == '-' ) {
+ return {};
+ }
+
+ CATCH_TRY {
+ size_t pos = 0;
+ const auto ret = std::stoull( trimmed, &pos, base );
+
+ // We did not consume the whole input, so there is an issue
+ // This can be bunch of different stuff, like multiple numbers
+ // in the input, or invalid digits/characters and so on. Either
+ // way, we do not want to return the partially parsed result.
+ if ( pos != trimmed.size() ) {
+ return {};
+ }
+ // Too large
+ if ( ret > std::numeric_limits<unsigned int>::max() ) {
+ return {};
+ }
+ return static_cast<unsigned int>(ret);
+ }
+ CATCH_CATCH_ANON( std::invalid_argument const& ) {
+ // no conversion could be performed
+ }
+ CATCH_CATCH_ANON( std::out_of_range const& ) {
+ // the input does not fit into an unsigned long long
+ }
+ return {};
+ }
+
+} // namespace Catch
+
+
+
+
#include <cmath>
namespace Catch {
@@ -4796,12 +4991,12 @@ namespace Catch {
struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
GeneratorBasePtr m_generator;
- GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
- : TrackerBase( nameAndLocation, ctx, parent )
+ GeneratorTracker( TestCaseTracking::NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+ : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent )
{}
~GeneratorTracker() override;
- static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+ static GeneratorTracker* acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocationRef const& nameAndLocation ) {
GeneratorTracker* tracker;
ITracker& currentTracker = ctx.currentTracker();
@@ -4828,18 +5023,14 @@ namespace Catch {
assert( childTracker->isGeneratorTracker() );
tracker = static_cast<GeneratorTracker*>( childTracker );
} else {
- auto newTracker =
- Catch::Detail::make_unique<GeneratorTracker>(
- nameAndLocation, ctx, ¤tTracker );
- tracker = newTracker.get();
- currentTracker.addChild( CATCH_MOVE(newTracker) );
+ return nullptr;
}
if( !tracker->isComplete() ) {
tracker->open();
}
- return *tracker;
+ return tracker;
}
// TrackerBase interface
@@ -4908,6 +5099,7 @@ namespace Catch {
// has a side-effect, where it consumes generator's current
// value, but we do not want to invoke the side-effect if
// this generator is still waiting for any child to start.
+ assert( m_generator && "Tracker without generator" );
if ( should_wait_for_child ||
( m_runState == CompletedSuccessfully &&
m_generator->countedNext() ) ) {
@@ -4946,13 +5138,8 @@ namespace Catch {
Totals RunContext::runTest(TestCaseHandle const& testCase) {
const Totals prevTotals = m_totals;
- std::string redirectedCout;
- std::string redirectedCerr;
-
auto const& testInfo = testCase.getTestCaseInfo();
-
m_reporter->testCaseStarting(testInfo);
-
m_activeTestCase = &testCase;
@@ -4994,9 +5181,11 @@ namespace Catch {
seedRng( *m_config );
uint64_t testRuns = 0;
+ std::string redirectedCout;
+ std::string redirectedCerr;
do {
m_trackerContext.startCycle();
- m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+ m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
m_reporter->testCasePartialStarting(testInfo, testRuns);
@@ -5007,7 +5196,7 @@ namespace Catch {
redirectedCerr += oneRunCerr;
const auto singleRunTotals = m_totals.delta(beforeRunTotals);
- auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, oneRunCout, oneRunCerr, aborting());
+ auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
++testRuns;
@@ -5022,8 +5211,8 @@ namespace Catch {
m_totals.testCases += deltaTotals.testCases;
m_reporter->testCaseEnded(TestCaseStats(testInfo,
deltaTotals,
- redirectedCout,
- redirectedCerr,
+ CATCH_MOVE(redirectedCout),
+ CATCH_MOVE(redirectedCerr),
aborting()));
m_activeTestCase = nullptr;
@@ -5037,6 +5226,9 @@ namespace Catch {
if (result.getResultType() == ResultWas::Ok) {
m_totals.assertions.passed++;
m_lastAssertionPassed = true;
+ } else if (result.getResultType() == ResultWas::ExplicitSkip) {
+ m_totals.assertions.skipped++;
+ m_lastAssertionPassed = true;
} else if (!result.succeeded()) {
m_lastAssertionPassed = false;
if (result.isOk()) {
@@ -5064,12 +5256,17 @@ namespace Catch {
m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
}
- bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
- ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+ bool RunContext::sectionStarted(StringRef sectionName, SourceLineInfo const& sectionLineInfo, Counts & assertions) {
+ ITracker& sectionTracker =
+ SectionTracker::acquire( m_trackerContext,
+ TestCaseTracking::NameAndLocationRef(
+ sectionName, sectionLineInfo ) );
+
if (!sectionTracker.isOpen())
return false;
m_activeSections.push_back(§ionTracker);
+ SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
m_reporter->sectionStarting(sectionInfo);
@@ -5078,14 +5275,39 @@ namespace Catch {
return true;
}
- auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+ IGeneratorTracker*
+ RunContext::acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) {
using namespace Generators;
- GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
- TestCaseTracking::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
+ GeneratorTracker* tracker = GeneratorTracker::acquire(
+ m_trackerContext,
+ TestCaseTracking::NameAndLocationRef(
+ generatorName, lineInfo ) );
m_lastAssertionInfo.lineInfo = lineInfo;
return tracker;
}
+ IGeneratorTracker* RunContext::createGeneratorTracker(
+ StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) {
+
+ auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
+ auto& currentTracker = m_trackerContext.currentTracker();
+ assert(
+ currentTracker.nameAndLocation() != nameAndLoc &&
+ "Trying to create tracker for a genreator that already has one" );
+
+ auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
+ CATCH_MOVE(nameAndLoc), m_trackerContext, ¤tTracker );
+ auto ret = newTracker.get();
+ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+
+ ret->setGenerator( CATCH_MOVE( generator ) );
+ ret->open();
+ return ret;
+ }
+
bool RunContext::testForMissingAssertions(Counts& assertions) {
if (assertions.total() != 0)
return false;
@@ -5098,7 +5320,7 @@ namespace Catch {
return true;
}
- void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+ void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions(assertions);
@@ -5107,19 +5329,20 @@ namespace Catch {
m_activeSections.pop_back();
}
- m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+ m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
m_messages.clear();
m_messageScopes.clear();
}
- void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
- if (m_unfinishedSections.empty())
+ void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
+ if ( m_unfinishedSections.empty() ) {
m_activeSections.back()->fail();
- else
+ } else {
m_activeSections.back()->close();
+ }
m_activeSections.pop_back();
- m_unfinishedSections.push_back(endInfo);
+ m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
}
void RunContext::benchmarkPreparing( StringRef name ) {
@@ -5143,8 +5366,8 @@ namespace Catch {
m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
}
- void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
- m_messageScopes.emplace_back( builder );
+ void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
+ m_messageScopes.emplace_back( CATCH_MOVE(builder) );
}
std::string RunContext::getCurrentTestName() const {
@@ -5169,7 +5392,7 @@ namespace Catch {
// Instead, fake a result data.
AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
tempResult.message = static_cast<std::string>(message);
- AssertionResult result(m_lastAssertionInfo, tempResult);
+ AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
assertionEnded(result);
@@ -5181,7 +5404,7 @@ namespace Catch {
Counts assertions;
assertions.failed = 1;
- SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
m_reporter->sectionEnded(testCaseSectionStats);
auto const& testInfo = m_activeTestCase->getTestCaseInfo();
@@ -5242,6 +5465,8 @@ namespace Catch {
duration = timer.getElapsedSeconds();
} CATCH_CATCH_ANON (TestFailureException&) {
// This just means the test was aborted due to failure
+ } CATCH_CATCH_ANON (TestSkipException&) {
+ // This just means the test was explicitly skipped
} CATCH_CATCH_ALL {
// Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
// are reported without translation at the point of origin.
@@ -5258,7 +5483,7 @@ namespace Catch {
m_messages.clear();
m_messageScopes.clear();
- SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
m_reporter->sectionEnded(testCaseSectionStats);
}
@@ -5282,7 +5507,7 @@ namespace Catch {
itEnd = m_unfinishedSections.rend();
it != itEnd;
++it)
- sectionEnded(*it);
+ sectionEnded(CATCH_MOVE(*it));
m_unfinishedSections.clear();
}
@@ -5318,7 +5543,7 @@ namespace Catch {
m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( negated ) );
- AssertionResult assertionResult{ info, data };
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
assertionEnded( assertionResult );
@@ -5336,10 +5561,16 @@ namespace Catch {
AssertionResultData data( resultType, LazyExpression( false ) );
data.message = static_cast<std::string>(message);
- AssertionResult assertionResult{ m_lastAssertionInfo, data };
+ AssertionResult assertionResult{ m_lastAssertionInfo,
+ CATCH_MOVE( data ) };
assertionEnded( assertionResult );
- if( !assertionResult.isOk() )
+ if ( !assertionResult.isOk() ) {
populateReaction( reaction );
+ } else if ( resultType == ResultWas::ExplicitSkip ) {
+ // TODO: Need to handle this explicitly, as ExplicitSkip is
+ // considered "OK"
+ reaction.shouldSkip = true;
+ }
}
void RunContext::handleUnexpectedExceptionNotThrown(
AssertionInfo const& info,
@@ -5357,7 +5588,7 @@ namespace Catch {
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
data.message = message;
- AssertionResult assertionResult{ info, data };
+ AssertionResult assertionResult{ info, CATCH_MOVE(data) };
assertionEnded( assertionResult );
populateReaction( reaction );
}
@@ -5370,11 +5601,12 @@ namespace Catch {
void RunContext::handleIncomplete(
AssertionInfo const& info
) {
+ using namespace std::string_literals;
m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
- data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
- AssertionResult assertionResult{ info, data };
+ data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
assertionEnded( assertionResult );
}
void RunContext::handleNonExpr(
@@ -5385,7 +5617,7 @@ namespace Catch {
m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( false ) );
- AssertionResult assertionResult{ info, data };
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
assertionEnded( assertionResult );
if( !assertionResult.isOk() )
@@ -5417,7 +5649,7 @@ namespace Catch {
Section::Section( SectionInfo&& info ):
m_info( CATCH_MOVE( info ) ),
m_sectionIncluded(
- getResultCapture().sectionStarted( m_info, m_assertions ) ) {
+ getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
// Non-"included" sections will not use the timing information
// anyway, so don't bother with the potential syscall.
if (m_sectionIncluded) {
@@ -5425,13 +5657,31 @@ namespace Catch {
}
}
+ Section::Section( SourceLineInfo const& _lineInfo,
+ StringRef _name,
+ const char* const ):
+ m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
+ m_sectionIncluded(
+ getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
+ // We delay initialization the SectionInfo member until we know
+ // this section needs it, so we avoid allocating std::string for name.
+ // We also delay timer start to avoid the potential syscall unless we
+ // will actually use the result.
+ if ( m_sectionIncluded ) {
+ m_info.name = static_cast<std::string>( _name );
+ m_info.lineInfo = _lineInfo;
+ m_timer.start();
+ }
+ }
+
Section::~Section() {
if( m_sectionIncluded ) {
- SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
- if( uncaught_exceptions() )
- getResultCapture().sectionEndedEarly( endInfo );
- else
- getResultCapture().sectionEnded( endInfo );
+ SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
+ if ( uncaught_exceptions() ) {
+ getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
+ } else {
+ getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
+ }
}
}
@@ -5647,10 +5897,6 @@ namespace Catch {
: StringRef( rawChars, std::strlen(rawChars) )
{}
- auto StringRef::operator == ( StringRef other ) const noexcept -> bool {
- return m_size == other.m_size
- && (std::memcmp( m_start, other.m_start, m_size ) == 0);
- }
bool StringRef::operator<(StringRef rhs) const noexcept {
if (m_size < rhs.m_size) {
@@ -5850,7 +6096,7 @@ namespace Catch {
TestCaseInfo const* rhs ) {
return *lhs < *rhs;
};
- std::set<TestCaseInfo const*, decltype(testInfoCmp)> seenTests(testInfoCmp);
+ std::set<TestCaseInfo const*, decltype(testInfoCmp) &> seenTests(testInfoCmp);
for ( auto const& test : tests ) {
const auto infoPtr = &test.getTestCaseInfo();
const auto prev = seenTests.insert( infoPtr );
@@ -5926,8 +6172,8 @@ namespace Catch {
namespace Catch {
namespace TestCaseTracking {
- NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
- : name( _name ),
+ NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
+ : name( CATCH_MOVE(_name) ),
location( _location )
{}
@@ -5942,14 +6188,17 @@ namespace TestCaseTracking {
m_children.push_back( CATCH_MOVE(child) );
}
- ITracker* ITracker::findChild( NameAndLocation const& nameAndLocation ) {
+ ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
auto it = std::find_if(
m_children.begin(),
m_children.end(),
[&nameAndLocation]( ITrackerPtr const& tracker ) {
- return tracker->nameAndLocation().location ==
- nameAndLocation.location &&
- tracker->nameAndLocation().name == nameAndLocation.name;
+ auto const& tnameAndLoc = tracker->nameAndLocation();
+ if ( tnameAndLoc.location.line !=
+ nameAndLocation.location.line ) {
+ return false;
+ }
+ return tnameAndLoc == nameAndLocation;
} );
return ( it != m_children.end() ) ? it->get() : nullptr;
}
@@ -5957,10 +6206,6 @@ namespace TestCaseTracking {
bool ITracker::isSectionTracker() const { return false; }
bool ITracker::isGeneratorTracker() const { return false; }
- bool ITracker::isSuccessfullyCompleted() const {
- return m_runState == CompletedSuccessfully;
- }
-
bool ITracker::isOpen() const {
return m_runState != NotStarted && !isComplete();
}
@@ -5987,16 +6232,6 @@ namespace TestCaseTracking {
return *m_rootTracker;
}
- void TrackerContext::endRun() {
- m_rootTracker.reset();
- m_currentTracker = nullptr;
- m_runState = NotStarted;
- }
-
- void TrackerContext::startCycle() {
- m_currentTracker = m_rootTracker.get();
- m_runState = Executing;
- }
void TrackerContext::completeCycle() {
m_runState = CompletedCycle;
}
@@ -6004,16 +6239,13 @@ namespace TestCaseTracking {
bool TrackerContext::completedCycle() const {
return m_runState == CompletedCycle;
}
- ITracker& TrackerContext::currentTracker() {
- return *m_currentTracker;
- }
void TrackerContext::setCurrentTracker( ITracker* tracker ) {
m_currentTracker = tracker;
}
- TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
- ITracker(nameAndLocation, parent),
+ TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
+ ITracker(CATCH_MOVE(nameAndLocation), parent),
m_ctx( ctx )
{}
@@ -6073,13 +6305,14 @@ namespace TestCaseTracking {
m_ctx.setCurrentTracker( this );
}
- SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
- : TrackerBase( nameAndLocation, ctx, parent ),
- m_trimmed_name(trim(nameAndLocation.name))
+ SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+ : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
+ m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
{
if( parent ) {
- while( !parent->isSectionTracker() )
+ while ( !parent->isSectionTracker() ) {
parent = parent->parent();
+ }
SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
addNextFilters( parentSection.m_filters );
@@ -6099,24 +6332,30 @@ namespace TestCaseTracking {
bool SectionTracker::isSectionTracker() const { return true; }
- SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
- SectionTracker* section;
+ SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
+ SectionTracker* tracker;
ITracker& currentTracker = ctx.currentTracker();
if ( ITracker* childTracker =
currentTracker.findChild( nameAndLocation ) ) {
assert( childTracker );
assert( childTracker->isSectionTracker() );
- section = static_cast<SectionTracker*>( childTracker );
+ tracker = static_cast<SectionTracker*>( childTracker );
} else {
- auto newSection = Catch::Detail::make_unique<SectionTracker>(
- nameAndLocation, ctx, ¤tTracker );
- section = newSection.get();
- currentTracker.addChild( CATCH_MOVE( newSection ) );
+ auto newTracker = Catch::Detail::make_unique<SectionTracker>(
+ NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
+ nameAndLocation.location },
+ ctx,
+ ¤tTracker );
+ tracker = newTracker.get();
+ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+ }
+
+ if ( !ctx.completedCycle() ) {
+ tracker->tryOpen();
}
- if( !ctx.completedCycle() )
- section->tryOpen();
- return *section;
+
+ return *tracker;
}
void SectionTracker::tryOpen() {
@@ -6137,10 +6376,6 @@ namespace TestCaseTracking {
m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
}
- std::vector<StringRef> const& SectionTracker::getFilters() const {
- return m_filters;
- }
-
StringRef SectionTracker::trimmedName() const {
return m_trimmed_name;
}
@@ -6155,6 +6390,21 @@ namespace TestCaseTracking {
+
+namespace Catch {
+
+ void throw_test_failure_exception() {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+ throw TestFailureException{};
+#else
+ CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+ }
+
+} // namespace Catch
+
+
+
#include <algorithm>
#include <iterator>
@@ -6424,10 +6674,8 @@ namespace Catch {
token.erase(token.begin());
if (m_exclusion) {
m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
- m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
} else {
m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
- m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
}
}
if (m_exclusion) {
@@ -6441,10 +6689,6 @@ namespace Catch {
m_mode = None;
}
- TestSpec parseTestSpec( std::string const& arg ) {
- return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
- }
-
} // namespace Catch
@@ -6757,6 +7001,7 @@ namespace Catch {
// while in /permissive- mode. No, I don't know why.
// Tested on VS 2019, 18.{3, 4}.x
+#include <cstdint>
#include <iomanip>
#include <type_traits>
@@ -7373,7 +7618,19 @@ WithinRelMatcher WithinRel(float target) {
}
-} // namespace Matchers
+
+bool IsNaNMatcher::match( double const& matchee ) const {
+ return std::isnan( matchee );
+}
+
+std::string IsNaNMatcher::describe() const {
+ using namespace std::string_literals;
+ return "is NaN"s;
+}
+
+IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
+
+ } // namespace Matchers
} // namespace Catch
@@ -7553,9 +7810,9 @@ namespace Catch {
// This is the general overload that takes a any string matcher
// There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
// the Equals matcher (so the header does not mention matchers)
- void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString ) {
+ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
std::string exceptionMessage = Catch::translateActiveException();
- MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher, matcherString );
+ MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
handler.handleExpr( expr );
}
@@ -7572,7 +7829,9 @@ namespace Catch {
void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
// Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
m_stream << ":test-result: ";
- if (_testCaseStats.totals.assertions.allPassed()) {
+ if ( _testCaseStats.totals.testCases.skipped > 0 ) {
+ m_stream << "SKIP";
+ } else if (_testCaseStats.totals.assertions.allPassed()) {
m_stream << "PASS";
} else if (_testCaseStats.totals.assertions.allOk()) {
m_stream << "XFAIL";
@@ -7634,22 +7893,6 @@ namespace Catch {
#include <ostream>
-namespace {
-
- constexpr Catch::StringRef bothOrAll( std::uint64_t count ) {
- switch (count) {
- case 1:
- return Catch::StringRef{};
- case 2:
- return "both "_catch_sr;
- default:
- return "all "_catch_sr;
- }
- }
-
-} // anon namespace
-
-
namespace Catch {
namespace {
@@ -7664,42 +7907,6 @@ namespace {
static constexpr Catch::StringRef compactPassedString = "passed"_sr;
#endif
-// Colour, message variants:
-// - white: No tests ran.
-// - red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// - red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals, ColourImpl* colourImpl) {
- if (totals.testCases.total() == 0) {
- out << "No tests ran.";
- } else if (totals.testCases.failed == totals.testCases.total()) {
- auto guard = colourImpl->guardColour( Colour::ResultError ).engage( out );
- const StringRef qualify_assertions_failed =
- totals.assertions.failed == totals.assertions.total() ?
- bothOrAll(totals.assertions.failed) : StringRef{};
- out <<
- "Failed " << bothOrAll(totals.testCases.failed)
- << pluralise(totals.testCases.failed, "test case"_sr) << ", "
- "failed " << qualify_assertions_failed <<
- pluralise(totals.assertions.failed, "assertion"_sr) << '.';
- } else if (totals.assertions.total() == 0) {
- out <<
- "Passed " << bothOrAll(totals.testCases.total())
- << pluralise(totals.testCases.total(), "test case"_sr)
- << " (no assertions).";
- } else if (totals.assertions.failed) {
- out << colourImpl->guardColour( Colour::ResultError ) <<
- "Failed " << pluralise(totals.testCases.failed, "test case"_sr) << ", "
- "failed " << pluralise(totals.assertions.failed, "assertion"_sr) << '.';
- } else {
- out << colourImpl->guardColour( Colour::ResultSuccess ) <<
- "Passed " << bothOrAll(totals.testCases.passed)
- << pluralise(totals.testCases.passed, "test case"_sr) <<
- " with " << pluralise(totals.assertions.passed, "assertion"_sr) << '.';
- }
-}
-
// Implementation of CompactReporter formatting
class AssertionPrinter {
public:
@@ -7773,6 +7980,11 @@ public:
printIssue("explicitly");
printRemainingMessages(Colour::None);
break;
+ case ResultWas::ExplicitSkip:
+ printResultType(Colour::Skip, "skipped"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
@@ -7855,7 +8067,7 @@ private:
private:
std::ostream& stream;
AssertionResult const& result;
- std::vector<MessageInfo> messages;
+ std::vector<MessageInfo> const& messages;
std::vector<MessageInfo>::const_iterator itMessage;
bool printInfoMessages;
ColourImpl* colourImpl;
@@ -7875,10 +8087,10 @@ private:
if ( m_config->testSpec().hasFilters() ) {
m_stream << m_colour->guardColour( Colour::BrightYellow )
<< "Filters: "
- << serializeFilters( m_config->getTestsOrTags() )
+ << m_config->testSpec()
<< '\n';
}
- m_stream << "RNG seed: " << m_config->rngSeed() << '\n';
+ m_stream << "RNG seed: " << getSeed() << '\n';
}
void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
@@ -7888,7 +8100,7 @@ private:
// Drop out if result was successful and we're not printing those
if( !m_config->includeSuccessfulResults() && result.isOk() ) {
- if( result.getResultType() != ResultWas::Warning )
+ if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
return;
printInfoMessages = false;
}
@@ -7907,7 +8119,7 @@ private:
}
void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
- printTotals( m_stream, _testRunStats.totals, m_colour.get() );
+ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
m_stream << "\n\n" << std::flush;
StreamingReporterBase::testRunEnded( _testRunStats );
}
@@ -7949,7 +8161,6 @@ public:
stats(_stats),
result(_stats.assertionResult),
colour(Colour::None),
- message(result.getMessage()),
messages(_stats.infoMessages),
colourImpl(colourImpl_),
printInfoMessages(_printInfoMessages) {
@@ -7958,10 +8169,10 @@ public:
colour = Colour::Success;
passOrFail = "PASSED"_sr;
//if( result.hasMessage() )
- if (_stats.infoMessages.size() == 1)
- messageLabel = "with message";
- if (_stats.infoMessages.size() > 1)
- messageLabel = "with messages";
+ if (messages.size() == 1)
+ messageLabel = "with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "with messages"_sr;
break;
case ResultWas::ExpressionFailed:
if (result.isOk()) {
@@ -7971,43 +8182,57 @@ public:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
}
- if (_stats.infoMessages.size() == 1)
- messageLabel = "with message";
- if (_stats.infoMessages.size() > 1)
- messageLabel = "with messages";
+ if (messages.size() == 1)
+ messageLabel = "with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "with messages"_sr;
break;
case ResultWas::ThrewException:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
- messageLabel = "due to unexpected exception with ";
- if (_stats.infoMessages.size() == 1)
- messageLabel += "message";
- if (_stats.infoMessages.size() > 1)
- messageLabel += "messages";
+ // todo switch
+ switch (messages.size()) { case 0:
+ messageLabel = "due to unexpected exception with "_sr;
+ break;
+ case 1:
+ messageLabel = "due to unexpected exception with message"_sr;
+ break;
+ default:
+ messageLabel = "due to unexpected exception with messages"_sr;
+ break;
+ }
break;
case ResultWas::FatalErrorCondition:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
- messageLabel = "due to a fatal error condition";
+ messageLabel = "due to a fatal error condition"_sr;
break;
case ResultWas::DidntThrowException:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
- messageLabel = "because no exception was thrown where one was expected";
+ messageLabel = "because no exception was thrown where one was expected"_sr;
break;
case ResultWas::Info:
- messageLabel = "info";
+ messageLabel = "info"_sr;
break;
case ResultWas::Warning:
- messageLabel = "warning";
+ messageLabel = "warning"_sr;
break;
case ResultWas::ExplicitFailure:
passOrFail = "FAILED"_sr;
colour = Colour::Error;
- if (_stats.infoMessages.size() == 1)
- messageLabel = "explicitly with message";
- if (_stats.infoMessages.size() > 1)
- messageLabel = "explicitly with messages";
+ if (messages.size() == 1)
+ messageLabel = "explicitly with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "explicitly with messages"_sr;
+ break;
+ case ResultWas::ExplicitSkip:
+ colour = Colour::Skip;
+ passOrFail = "SKIPPED"_sr;
+ if (messages.size() == 1)
+ messageLabel = "explicitly with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "explicitly with messages"_sr;
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
@@ -8071,9 +8296,8 @@ private:
AssertionResult const& result;
Colour::Code colour;
StringRef passOrFail;
- std::string messageLabel;
- std::string message;
- std::vector<MessageInfo> messages;
+ StringRef messageLabel;
+ std::vector<MessageInfo> const& messages;
ColourImpl* colourImpl;
bool printInfoMessages;
};
@@ -8083,13 +8307,16 @@ std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
}
-std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
- if (i > j && i > k)
+std::size_t&
+findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
+ if (i > j && i > k && i > l)
return i;
- else if (j > k)
+ else if (j > k && j > l)
return j;
- else
+ else if (k > l)
return k;
+ else
+ return l;
}
enum class Justification { Left, Right };
@@ -8298,7 +8525,8 @@ void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
// Drop out if result was successful but we're not printing them.
- if (!includeResults && result.getResultType() != ResultWas::Warning)
+ // TODO: Make configurable whether skips should be printed
+ if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
return;
lazyPrint();
@@ -8389,7 +8617,7 @@ void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
}
void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
printTotalsDivider(_testRunStats.totals);
- printTotals(_testRunStats.totals);
+ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
m_stream << '\n' << std::flush;
StreamingReporterBase::testRunEnded(_testRunStats);
}
@@ -8397,9 +8625,9 @@ void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
StreamingReporterBase::testRunStarting(_testInfo);
if ( m_config->testSpec().hasFilters() ) {
m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
- << serializeFilters( m_config->getTestsOrTags() ) << '\n';
+ << m_config->testSpec() << '\n';
}
- m_stream << "Randomness seeded to: " << m_config->rngSeed() << '\n';
+ m_stream << "Randomness seeded to: " << getSeed() << '\n';
}
void ConsoleReporter::lazyPrint() {
@@ -8496,91 +8724,16 @@ void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t
<< '\n';
}
-struct SummaryColumn {
-
- SummaryColumn( std::string _label, Colour::Code _colour )
- : label( CATCH_MOVE( _label ) ),
- colour( _colour ) {}
- SummaryColumn addRow( std::uint64_t count ) {
- ReusableStringStream rss;
- rss << count;
- std::string row = rss.str();
- for (auto& oldRow : rows) {
- while (oldRow.size() < row.size())
- oldRow = ' ' + oldRow;
- while (oldRow.size() > row.size())
- row = ' ' + row;
- }
- rows.push_back(row);
- return *this;
- }
-
- std::string label;
- Colour::Code colour;
- std::vector<std::string> rows;
-
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
- if (totals.testCases.total() == 0) {
- m_stream << m_colour->guardColour( Colour::Warning )
- << "No tests ran\n";
- } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
- m_stream << m_colour->guardColour( Colour::ResultSuccess )
- << "All tests passed";
- m_stream << " ("
- << pluralise(totals.assertions.passed, "assertion"_sr) << " in "
- << pluralise(totals.testCases.passed, "test case"_sr) << ')'
- << '\n';
- } else {
-
- std::vector<SummaryColumn> columns;
- columns.push_back(SummaryColumn("", Colour::None)
- .addRow(totals.testCases.total())
- .addRow(totals.assertions.total()));
- columns.push_back(SummaryColumn("passed", Colour::Success)
- .addRow(totals.testCases.passed)
- .addRow(totals.assertions.passed));
- columns.push_back(SummaryColumn("failed", Colour::ResultError)
- .addRow(totals.testCases.failed)
- .addRow(totals.assertions.failed));
- columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
- .addRow(totals.testCases.failedButOk)
- .addRow(totals.assertions.failedButOk));
-
- printSummaryRow("test cases"_sr, columns, 0);
- printSummaryRow("assertions"_sr, columns, 1);
- }
-}
-void ConsoleReporter::printSummaryRow(StringRef label, std::vector<SummaryColumn> const& cols, std::size_t row) {
- for (auto col : cols) {
- std::string const& value = col.rows[row];
- if (col.label.empty()) {
- m_stream << label << ": ";
- if ( value != "0" ) {
- m_stream << value;
- } else {
- m_stream << m_colour->guardColour( Colour::Warning )
- << "- none -";
- }
- } else if (value != "0") {
- m_stream << m_colour->guardColour( Colour::LightGrey ) << " | "
- << m_colour->guardColour( col.colour ) << value << ' '
- << col.label;
- }
- }
- m_stream << '\n';
-}
-
void ConsoleReporter::printTotalsDivider(Totals const& totals) {
if (totals.testCases.total() > 0) {
std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
- while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
- findMax(failedRatio, failedButOkRatio, passedRatio)++;
+ std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
+ while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
- findMax(failedRatio, failedButOkRatio, passedRatio)--;
+ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
m_stream << m_colour->guardColour( Colour::Error )
<< std::string( failedRatio, '=' )
@@ -8593,15 +8746,14 @@ void ConsoleReporter::printTotalsDivider(Totals const& totals) {
m_stream << m_colour->guardColour( Colour::Success )
<< std::string( passedRatio, '=' );
}
+ m_stream << m_colour->guardColour( Colour::Skip )
+ << std::string( skippedRatio, '=' );
} else {
m_stream << m_colour->guardColour( Colour::Warning )
<< std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
}
m_stream << '\n';
}
-void ConsoleReporter::printSummaryDivider() {
- m_stream << lineOfChars('-') << '\n';
-}
} // end namespace Catch
@@ -8677,7 +8829,8 @@ namespace Catch {
void
CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
- SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+ // We need a copy, because SectionStats expect to take ownership
+ SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
SectionNode* node;
if ( m_sectionStack.empty() ) {
if ( !m_rootSection ) {
@@ -9019,6 +9172,111 @@ namespace Catch {
out << "\n\n" << std::flush;
}
+ namespace {
+ class SummaryColumn {
+ public:
+ SummaryColumn( std::string suffix, Colour::Code colour ):
+ m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
+
+ SummaryColumn&& addRow( std::uint64_t count ) && {
+ std::string row = std::to_string(count);
+ auto const new_width = std::max( m_width, row.size() );
+ if ( new_width > m_width ) {
+ for ( auto& oldRow : m_rows ) {
+ oldRow.insert( 0, new_width - m_width, ' ' );
+ }
+ } else {
+ row.insert( 0, m_width - row.size(), ' ' );
+ }
+ m_width = new_width;
+ m_rows.push_back( row );
+ return std::move( *this );
+ }
+
+ std::string const& getSuffix() const { return m_suffix; }
+ Colour::Code getColour() const { return m_colour; }
+ std::string const& getRow( std::size_t index ) const {
+ return m_rows[index];
+ }
+
+ private:
+ std::string m_suffix;
+ Colour::Code m_colour;
+ std::size_t m_width = 0;
+ std::vector<std::string> m_rows;
+ };
+
+ void printSummaryRow( std::ostream& stream,
+ ColourImpl& colour,
+ StringRef label,
+ std::vector<SummaryColumn> const& cols,
+ std::size_t row ) {
+ for ( auto const& col : cols ) {
+ auto const& value = col.getRow( row );
+ auto const& suffix = col.getSuffix();
+ if ( suffix.empty() ) {
+ stream << label << ": ";
+ if ( value != "0" ) {
+ stream << value;
+ } else {
+ stream << colour.guardColour( Colour::Warning )
+ << "- none -";
+ }
+ } else if ( value != "0" ) {
+ stream << colour.guardColour( Colour::LightGrey ) << " | "
+ << colour.guardColour( col.getColour() ) << value
+ << ' ' << suffix;
+ }
+ }
+ stream << '\n';
+ }
+ } // namespace
+
+ void printTestRunTotals( std::ostream& stream,
+ ColourImpl& streamColour,
+ Totals const& totals ) {
+ if ( totals.testCases.total() == 0 ) {
+ stream << streamColour.guardColour( Colour::Warning )
+ << "No tests ran\n";
+ return;
+ }
+
+ if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
+ stream << streamColour.guardColour( Colour::ResultSuccess )
+ << "All tests passed";
+ stream << " ("
+ << pluralise( totals.assertions.passed, "assertion"_sr )
+ << " in "
+ << pluralise( totals.testCases.passed, "test case"_sr )
+ << ')' << '\n';
+ return;
+ }
+
+ std::vector<SummaryColumn> columns;
+ // Don't include "skipped assertions" in total count
+ const auto totalAssertionCount =
+ totals.assertions.total() - totals.assertions.skipped;
+ columns.push_back( SummaryColumn( "", Colour::None )
+ .addRow( totals.testCases.total() )
+ .addRow( totalAssertionCount ) );
+ columns.push_back( SummaryColumn( "passed", Colour::Success )
+ .addRow( totals.testCases.passed )
+ .addRow( totals.assertions.passed ) );
+ columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+ .addRow( totals.testCases.failed )
+ .addRow( totals.assertions.failed ) );
+ columns.push_back( SummaryColumn( "skipped", Colour::Skip )
+ .addRow( totals.testCases.skipped )
+ // Don't print "skipped assertions"
+ .addRow( 0 ) );
+ columns.push_back(
+ SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+ .addRow( totals.testCases.failedButOk )
+ .addRow( totals.assertions.failedButOk ) );
+ printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
+ printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
+ }
+
} // namespace Catch
@@ -9039,6 +9297,8 @@ namespace Catch {
std::tm timeInfo = {};
#if defined (_MSC_VER) || defined (__MINGW32__)
gmtime_s(&timeInfo, &rawtime);
+#elif defined (CATCH_PLATFORM_PLAYSTATION)
+ gmtime_s(&rawtime, &timeInfo);
#else
gmtime_r(&rawtime, &timeInfo);
#endif
@@ -9138,6 +9398,7 @@ namespace Catch {
xml.writeAttribute( "name"_sr, stats.runInfo.name );
xml.writeAttribute( "errors"_sr, unexpectedExceptions );
xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
+ xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
if( m_config->showDurations() == ShowDurations::Never )
@@ -9152,10 +9413,10 @@ namespace Catch {
xml.scopedElement("property")
.writeAttribute("name"_sr, "random-seed"_sr)
.writeAttribute("value"_sr, m_config->rngSeed());
- if (m_config->hasTestFilters()) {
+ if (m_config->testSpec().hasFilters()) {
xml.scopedElement("property")
.writeAttribute("name"_sr, "filters"_sr)
- .writeAttribute("value"_sr, serializeFilters(m_config->getTestsOrTags()));
+ .writeAttribute("value"_sr, m_config->testSpec());
}
}
@@ -9250,7 +9511,8 @@ namespace Catch {
void JunitReporter::writeAssertion( AssertionStats const& stats ) {
AssertionResult const& result = stats.assertionResult;
- if( !result.isOk() ) {
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
std::string elementName;
switch( result.getResultType() ) {
case ResultWas::ThrewException:
@@ -9262,7 +9524,9 @@ namespace Catch {
case ResultWas::DidntThrowException:
elementName = "failure";
break;
-
+ case ResultWas::ExplicitSkip:
+ elementName = "skipped";
+ break;
// We should never see these here:
case ResultWas::Info:
case ResultWas::Warning:
@@ -9280,7 +9544,9 @@ namespace Catch {
xml.writeAttribute( "type"_sr, result.getTestMacroName() );
ReusableStringStream rss;
- if (stats.totals.assertions.total() > 0) {
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ rss << "SKIPPED\n";
+ } else {
rss << "FAILED" << ":\n";
if (result.hasExpression()) {
rss << " ";
@@ -9291,8 +9557,6 @@ namespace Catch {
rss << "with expansion:\n";
rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
}
- } else {
- rss << '\n';
}
if( !result.getMessage().empty() )
@@ -9528,9 +9792,14 @@ namespace Catch {
namespace Catch {
namespace {
- std::string createRngSeedString(uint32_t seed) {
+ std::string createMetadataString(IConfig const& config) {
ReusableStringStream sstr;
- sstr << "rng-seed=" << seed;
+ if ( config.testSpec().hasFilters() ) {
+ sstr << "filters='"
+ << config.testSpec()
+ << "' ";
+ }
+ sstr << "rng-seed=" << config.rngSeed();
return sstr.str();
}
}
@@ -9538,13 +9807,13 @@ namespace Catch {
void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
CumulativeReporterBase::testRunStarting(testRunInfo);
- xml.writeComment( createRngSeedString( m_config->rngSeed() ) );
+ xml.writeComment( createMetadataString( *m_config ) );
xml.startElement("testExecutions");
xml.writeAttribute("version"_sr, '1');
}
void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
- std::map<std::string, std::vector<TestCaseNode const*>> testsPerFile;
+ std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
for ( auto const& child : runNode.children ) {
testsPerFile[child->value.testInfo->lineInfo.file].push_back(
@@ -9556,7 +9825,7 @@ namespace Catch {
}
}
- void SonarQubeReporter::writeTestFile(std::string const& filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
+ void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
XmlWriter::ScopedElement e = xml.scopedElement("file");
xml.writeAttribute("path"_sr, filename);
@@ -9601,7 +9870,8 @@ namespace Catch {
void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
AssertionResult const& result = stats.assertionResult;
- if (!result.isOk()) {
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
std::string elementName;
if (okToFail) {
elementName = "skipped";
@@ -9612,15 +9882,13 @@ namespace Catch {
elementName = "error";
break;
case ResultWas::ExplicitFailure:
- elementName = "failure";
- break;
case ResultWas::ExpressionFailed:
- elementName = "failure";
- break;
case ResultWas::DidntThrowException:
elementName = "failure";
break;
-
+ case ResultWas::ExplicitSkip:
+ elementName = "skipped";
+ break;
// We should never see these here:
case ResultWas::Info:
case ResultWas::Warning:
@@ -9640,7 +9908,9 @@ namespace Catch {
xml.writeAttribute("message"_sr, messageRss.str());
ReusableStringStream textRss;
- if (stats.totals.assertions.total() > 0) {
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ textRss << "SKIPPED\n";
+ } else {
textRss << "FAILED:\n";
if (result.hasExpression()) {
textRss << '\t' << result.getExpressionInMacro() << '\n';
@@ -9770,6 +10040,12 @@ namespace Catch {
printIssue("explicitly"_sr);
printRemainingMessages(Colour::None);
break;
+ case ResultWas::ExplicitSkip:
+ printResultType(tapPassedString);
+ printIssue(" # SKIP"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
@@ -9848,7 +10124,7 @@ namespace Catch {
private:
std::ostream& stream;
AssertionResult const& result;
- std::vector<MessageInfo> messages;
+ std::vector<MessageInfo> const& messages;
std::vector<MessageInfo>::const_iterator itMessage;
bool printInfoMessages;
std::size_t counter;
@@ -9858,6 +10134,9 @@ namespace Catch {
} // End anonymous namespace
void TAPReporter::testRunStarting( TestRunInfo const& ) {
+ if ( m_config->testSpec().hasFilters() ) {
+ m_stream << "# filters: " << m_config->testSpec() << '\n';
+ }
m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
}
@@ -9938,7 +10217,8 @@ namespace Catch {
void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
AssertionResult const& result = assertionStats.assertionResult;
- if (!result.isOk()) {
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
ReusableStringStream msg;
if (!m_headerPrintedForThisSection)
@@ -9963,6 +10243,9 @@ namespace Catch {
case ResultWas::ExplicitFailure:
msg << "explicit failure";
break;
+ case ResultWas::ExplicitSkip:
+ msg << "explicit skip";
+ break;
// We shouldn't get here because of the isOk() test
case ResultWas::Ok:
@@ -9990,18 +10273,16 @@ namespace Catch {
" " << result.getExpandedExpression() << '\n';
}
- if (currentTestCaseInfo->okToFail()) {
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ m_stream << "##teamcity[testIgnored";
+ } else if ( currentTestCaseInfo->okToFail() ) {
msg << "- failure ignore as test marked as 'ok to fail'\n";
- m_stream << "##teamcity[testIgnored"
- << " name='" << escape(currentTestCaseInfo->name) << '\''
- << " message='" << escape(msg.str()) << '\''
- << "]\n";
+ m_stream << "##teamcity[testIgnored";
} else {
- m_stream << "##teamcity[testFailed"
- << " name='" << escape(currentTestCaseInfo->name) << '\''
- << " message='" << escape(msg.str()) << '\''
- << "]\n";
+ m_stream << "##teamcity[testFailed";
}
+ m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
+ << " message='" << escape( msg.str() ) << '\'' << "]\n";
}
m_stream.flush();
}
@@ -10096,15 +10377,17 @@ namespace Catch {
m_xml.startElement("Catch2TestRun")
.writeAttribute("name"_sr, m_config->name())
.writeAttribute("rng-seed"_sr, m_config->rngSeed())
+ .writeAttribute("xml-format-version"_sr, 2)
.writeAttribute("catch2-version"_sr, libraryVersion());
- if (m_config->testSpec().hasFilters())
- m_xml.writeAttribute( "filters"_sr, serializeFilters( m_config->getTestsOrTags() ) );
+ if ( m_config->testSpec().hasFilters() ) {
+ m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
+ }
}
void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
StreamingReporterBase::testCaseStarting(testInfo);
m_xml.startElement( "TestCase" )
- .writeAttribute( "name"_sr, trim( testInfo.name ) )
+ .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
.writeAttribute( "tags"_sr, testInfo.tagsAsString() );
writeSourceInfo( testInfo.lineInfo );
@@ -10118,7 +10401,7 @@ namespace Catch {
StreamingReporterBase::sectionStarting( sectionInfo );
if( m_sectionDepth++ > 0 ) {
m_xml.startElement( "Section" )
- .writeAttribute( "name"_sr, trim( sectionInfo.name ) );
+ .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
writeSourceInfo( sectionInfo.lineInfo );
m_xml.ensureTagClosed();
}
@@ -10146,9 +10429,10 @@ namespace Catch {
}
// Drop out if result was successful but we're not printing them.
- if( !includeResults && result.getResultType() != ResultWas::Warning )
+ if ( !includeResults && result.getResultType() != ResultWas::Warning &&
+ result.getResultType() != ResultWas::ExplicitSkip ) {
return;
-
+ }
// Print the expression if there is one.
if( result.hasExpression() ) {
@@ -10191,6 +10475,12 @@ namespace Catch {
m_xml.writeText( result.getMessage() );
m_xml.endElement();
break;
+ case ResultWas::ExplicitSkip:
+ m_xml.startElement( "Skip" );
+ writeSourceInfo( result.getSourceInfo() );
+ m_xml.writeText( result.getMessage() );
+ m_xml.endElement();
+ break;
default:
break;
}
@@ -10201,15 +10491,18 @@ namespace Catch {
void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
StreamingReporterBase::sectionEnded( sectionStats );
- if( --m_sectionDepth > 0 ) {
- XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
- e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
- e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
- e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
-
- if ( m_config->showDurations() == ShowDurations::Always )
- e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
+ if ( --m_sectionDepth > 0 ) {
+ {
+ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+ e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
+ e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
+ e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
+ e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
+ if ( m_config->showDurations() == ShowDurations::Always )
+ e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
+ }
+ // Ends assertion tag
m_xml.endElement();
}
}
@@ -10218,14 +10511,14 @@ namespace Catch {
StreamingReporterBase::testCaseEnded( testCaseStats );
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
+ e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
if ( m_config->showDurations() == ShowDurations::Always )
e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
-
if( !testCaseStats.stdOut.empty() )
- m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+ m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
if( !testCaseStats.stdErr.empty() )
- m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+ m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
m_xml.endElement();
}
@@ -10235,11 +10528,13 @@ namespace Catch {
m_xml.scopedElement( "OverallResults" )
.writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
.writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
- .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk );
+ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
+ .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
m_xml.scopedElement( "OverallResultsCases")
.writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
.writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
- .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk );
+ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
+ .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
m_xml.endElement();
}
diff --git a/packages/Catch2/extras/catch_amalgamated.hpp b/packages/Catch2/extras/catch_amalgamated.hpp
index 757e10c5ac5bb9fe164244c809edc189a931c40f..321cec5dac0647cc2065db5983ddd4ad9898438f 100644
--- a/packages/Catch2/extras/catch_amalgamated.hpp
+++ b/packages/Catch2/extras/catch_amalgamated.hpp
@@ -1,12 +1,12 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
-// Catch v3.1.0
-// Generated: 2022-07-17 20:14:04.055157
+// Catch v3.3.2
+// Generated: 2023-02-26 10:28:46.785908
// ----------------------------------------------------------
// This file is an amalgamation of multiple different files.
// You probably shouldn't edit it directly.
@@ -95,6 +95,8 @@ namespace Catch {
#include <iosfwd>
#include <cassert>
+#include <cstring>
+
namespace Catch {
/// A non-owning string class (similar to the forthcoming std::string_view)
@@ -131,7 +133,10 @@ namespace Catch {
}
public: // operators
- auto operator == ( StringRef other ) const noexcept -> bool;
+ auto operator == ( StringRef other ) const noexcept -> bool {
+ return m_size == other.m_size
+ && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+ }
auto operator != (StringRef other) const noexcept -> bool {
return !(*this == other);
}
@@ -326,6 +331,14 @@ namespace Catch {
#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
# define CATCH_PLATFORM_WINDOWS
+
+# if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
+# define CATCH_PLATFORM_WINDOWS_UWP
+# endif
+
+#elif defined(__ORBIS__) || defined(__PROSPERO__)
+# define CATCH_PLATFORM_PLAYSTATION
+
#endif
#endif // CATCH_PLATFORM_HPP_INCLUDED
@@ -344,7 +357,7 @@ namespace Catch {
// Only GCC compiler should be used in this block, so other compilers trying to
// mask themselves as GCC should be ignored.
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" )
@@ -356,14 +369,28 @@ namespace Catch {
# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
_Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
+# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+ _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
+
# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
#endif
+#if defined(__NVCOMPILER)
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "diag pop" )
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
+#endif
+
#if defined(__CUDACC__) && !defined(__clang__)
+# ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+// New pragmas introduced in CUDA 11.5+
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic pop" )
# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
+# else
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
+# endif
#endif
// clang-cl defines _MSC_VER as well as __clang__, which could cause the
@@ -414,23 +441,32 @@ namespace Catch {
# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
_Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-#endif // __clang__
+# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
+#endif // __clang__
-////////////////////////////////////////////////////////////////////////////////
-// Assume that non-Windows platforms support posix signals by default
-#if !defined(CATCH_PLATFORM_WINDOWS)
- #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
////////////////////////////////////////////////////////////////////////////////
// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
- #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#if defined( CATCH_PLATFORM_WINDOWS ) || \
+ defined( CATCH_PLATFORM_PLAYSTATION ) || \
+ defined( __CYGWIN__ ) || \
+ defined( __QNX__ ) || \
+ defined( __EMSCRIPTEN__ ) || \
+ defined( __DJGPP__ ) || \
+ defined( __OS400__ )
+# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#else
+# define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
#endif
-#ifdef __OS400__
-# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+////////////////////////////////////////////////////////////////////////////////
+// Assume that some platforms do not support getenv.
+#if defined(CATCH_PLATFORM_WINDOWS_UWP) || defined(CATCH_PLATFORM_PLAYSTATION)
+# define CATCH_INTERNAL_CONFIG_NO_GETENV
+#else
+# define CATCH_INTERNAL_CONFIG_GETENV
#endif
////////////////////////////////////////////////////////////////////////////////
@@ -472,12 +508,18 @@ namespace Catch {
// Visual C++
#if defined(_MSC_VER)
-# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) )
+// We want to defer to nvcc-specific warning suppression if we are compiled
+// with nvcc masquerading for MSVC.
+# if !defined( __CUDACC__ )
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ __pragma( warning( push ) )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ __pragma( warning( pop ) )
+# endif
// Universal Windows platform does not support SEH
// Or console colours (or console at all...)
-# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+# if defined(CATCH_PLATFORM_WINDOWS_UWP)
# define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
# else
# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
@@ -573,6 +615,10 @@ namespace Catch {
# define CATCH_CONFIG_POSIX_SIGNALS
#endif
+#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
+# define CATCH_CONFIG_GETENV
+#endif
+
#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
# define CATCH_CONFIG_CPP11_TO_STRING
#endif
@@ -638,6 +684,9 @@ namespace Catch {
#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
+#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
#endif
@@ -658,6 +707,10 @@ namespace Catch {
# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
+#endif
+
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
#define CATCH_TRY if ((true))
#define CATCH_CATCH_ALL if ((false))
@@ -679,6 +732,16 @@ namespace Catch {
# define CATCH_CONFIG_COLOUR_WIN32
#endif
+#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
+ !defined( CATCH_CONFIG_STATIC )
+# ifdef Catch2_EXPORTS
+# define CATCH_EXPORT //__declspec( dllexport ) // not needed
+# else
+# define CATCH_EXPORT __declspec( dllimport )
+# endif
+#else
+# define CATCH_EXPORT
+#endif
#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
@@ -686,6 +749,7 @@ namespace Catch {
#ifndef CATCH_CONTEXT_HPP_INCLUDED
#define CATCH_CONTEXT_HPP_INCLUDED
+
namespace Catch {
class IResultCapture;
@@ -706,7 +770,7 @@ namespace Catch {
virtual void setConfig( IConfig const* config ) = 0;
private:
- static IMutableContext *currentContext;
+ CATCH_EXPORT static IMutableContext* currentContext;
friend IMutableContext& getCurrentMutableContext();
friend void cleanUpContext();
static void createContext();
@@ -808,6 +872,7 @@ namespace Catch {
std::uint64_t passed = 0;
std::uint64_t failed = 0;
std::uint64_t failedButOk = 0;
+ std::uint64_t skipped = 0;
};
struct Totals {
@@ -874,6 +939,8 @@ namespace Catch {
Ok = 0,
Info = 1,
Warning = 2,
+ // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
+ ExplicitSkip = 4,
FailureBit = 0x10,
@@ -983,7 +1050,7 @@ namespace Catch {
class AssertionResult {
public:
AssertionResult() = delete;
- AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+ AssertionResult( AssertionInfo const& info, AssertionResultData&& data );
bool isOk() const;
bool succeeded() const;
@@ -1020,116 +1087,6 @@ namespace Catch {
#include <chrono>
-namespace Catch {
-
- class AssertionResult;
- struct AssertionInfo;
- struct SectionInfo;
- struct SectionEndInfo;
- struct MessageInfo;
- struct MessageBuilder;
- struct Counts;
- struct AssertionReaction;
- struct SourceLineInfo;
-
- class ITransientExpression;
- class IGeneratorTracker;
-
- struct BenchmarkInfo;
- template <typename Duration = std::chrono::duration<double, std::nano>>
- struct BenchmarkStats;
-
- class IResultCapture {
- public:
- virtual ~IResultCapture();
-
- virtual bool sectionStarted( SectionInfo const& sectionInfo,
- Counts& assertions ) = 0;
- virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
- virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
- virtual auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
-
- virtual void benchmarkPreparing( StringRef name ) = 0;
- virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
- virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
- virtual void benchmarkFailed( StringRef error ) = 0;
-
- virtual void pushScopedMessage( MessageInfo const& message ) = 0;
- virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
- virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
-
- virtual void handleFatalErrorCondition( StringRef message ) = 0;
-
- virtual void handleExpr
- ( AssertionInfo const& info,
- ITransientExpression const& expr,
- AssertionReaction& reaction ) = 0;
- virtual void handleMessage
- ( AssertionInfo const& info,
- ResultWas::OfType resultType,
- StringRef message,
- AssertionReaction& reaction ) = 0;
- virtual void handleUnexpectedExceptionNotThrown
- ( AssertionInfo const& info,
- AssertionReaction& reaction ) = 0;
- virtual void handleUnexpectedInflightException
- ( AssertionInfo const& info,
- std::string const& message,
- AssertionReaction& reaction ) = 0;
- virtual void handleIncomplete
- ( AssertionInfo const& info ) = 0;
- virtual void handleNonExpr
- ( AssertionInfo const &info,
- ResultWas::OfType resultType,
- AssertionReaction &reaction ) = 0;
-
-
-
- virtual bool lastAssertionPassed() = 0;
- virtual void assertionPassed() = 0;
-
- // Deprecated, do not use:
- virtual std::string getCurrentTestName() const = 0;
- virtual const AssertionResult* getLastResult() const = 0;
- virtual void exceptionEarlyReported() = 0;
- };
-
- IResultCapture& getResultCapture();
-}
-
-#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
- struct MessageInfo {
- MessageInfo( StringRef _macroName,
- SourceLineInfo const& _lineInfo,
- ResultWas::OfType _type );
-
- StringRef macroName;
- std::string message;
- SourceLineInfo lineInfo;
- ResultWas::OfType type;
- unsigned int sequence;
-
- bool operator == (MessageInfo const& other) const {
- return sequence == other.sequence;
- }
- bool operator < (MessageInfo const& other) const {
- return sequence < other.sequence;
- }
- private:
- static unsigned int globalCount;
- };
-
-} // end namespace Catch
-
-#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
-
#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
#define CATCH_UNIQUE_PTR_HPP_INCLUDED
@@ -1242,6 +1199,129 @@ namespace Detail {
#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED
+namespace Catch {
+
+ class AssertionResult;
+ struct AssertionInfo;
+ struct SectionInfo;
+ struct SectionEndInfo;
+ struct MessageInfo;
+ struct MessageBuilder;
+ struct Counts;
+ struct AssertionReaction;
+ struct SourceLineInfo;
+
+ class ITransientExpression;
+ class IGeneratorTracker;
+
+ struct BenchmarkInfo;
+ template <typename Duration = std::chrono::duration<double, std::nano>>
+ struct BenchmarkStats;
+
+ namespace Generators {
+ class GeneratorUntypedBase;
+ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+ }
+
+
+ class IResultCapture {
+ public:
+ virtual ~IResultCapture();
+
+ virtual bool sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) = 0;
+ virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
+ virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
+
+ virtual IGeneratorTracker*
+ acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) = 0;
+ virtual IGeneratorTracker*
+ createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) = 0;
+
+ virtual void benchmarkPreparing( StringRef name ) = 0;
+ virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+ virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+ virtual void benchmarkFailed( StringRef error ) = 0;
+
+ virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+ virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+ virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
+
+ virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+ virtual void handleExpr
+ ( AssertionInfo const& info,
+ ITransientExpression const& expr,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleMessage
+ ( AssertionInfo const& info,
+ ResultWas::OfType resultType,
+ StringRef message,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleUnexpectedExceptionNotThrown
+ ( AssertionInfo const& info,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleUnexpectedInflightException
+ ( AssertionInfo const& info,
+ std::string const& message,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleIncomplete
+ ( AssertionInfo const& info ) = 0;
+ virtual void handleNonExpr
+ ( AssertionInfo const &info,
+ ResultWas::OfType resultType,
+ AssertionReaction &reaction ) = 0;
+
+
+
+ virtual bool lastAssertionPassed() = 0;
+ virtual void assertionPassed() = 0;
+
+ // Deprecated, do not use:
+ virtual std::string getCurrentTestName() const = 0;
+ virtual const AssertionResult* getLastResult() const = 0;
+ virtual void exceptionEarlyReported() = 0;
+ };
+
+ IResultCapture& getResultCapture();
+}
+
+#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+ struct MessageInfo {
+ MessageInfo( StringRef _macroName,
+ SourceLineInfo const& _lineInfo,
+ ResultWas::OfType _type );
+
+ StringRef macroName;
+ std::string message;
+ SourceLineInfo lineInfo;
+ ResultWas::OfType type;
+ unsigned int sequence;
+
+ bool operator == (MessageInfo const& other) const {
+ return sequence == other.sequence;
+ }
+ bool operator < (MessageInfo const& other) const {
+ return sequence < other.sequence;
+ }
+ private:
+ static unsigned int globalCount;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
+
// Adapted from donated nonius code.
@@ -1351,7 +1431,7 @@ namespace Catch {
};
struct SectionStats {
- SectionStats( SectionInfo const& _sectionInfo,
+ SectionStats( SectionInfo&& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions );
@@ -1365,8 +1445,8 @@ namespace Catch {
struct TestCaseStats {
TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
- std::string const& _stdOut,
- std::string const& _stdErr,
+ std::string&& _stdOut,
+ std::string&& _stdErr,
bool _aborting );
TestCaseInfo const * testInfo;
@@ -1515,7 +1595,12 @@ namespace Catch {
*/
virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
- //! Called with test cases that are skipped due to the test run aborting
+ /**
+ * Called with test cases that are skipped due to the test run aborting.
+ * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
+ *
+ * Deprecated - will be removed in the next major release.
+ */
virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
//! Called if a fatal error (signal/structured exception) occured
@@ -1699,6 +1784,16 @@ namespace Catch {
//! Used to signal that an assertion macro failed
struct TestFailureException{};
+ /**
+ * Outlines throwing of `TestFailureException` into a single TU
+ *
+ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+ */
+ [[noreturn]] void throw_test_failure_exception();
+
+ //! Used to signal that the remainder of a test should be skipped
+ struct TestSkipException{};
+
} // namespace Catch
#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
@@ -1710,15 +1805,14 @@ namespace Catch {
#include <type_traits>
namespace Catch {
- template<typename T>
- struct always_false : std::false_type {};
+ template <typename>
+ struct true_given : std::true_type {};
- template <typename> struct true_given : std::true_type {};
struct is_callable_tester {
template <typename Fun, typename... Args>
- true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+ static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
template <typename...>
- std::false_type static test(...);
+ static std::false_type test(...);
};
template <typename T>
@@ -2609,7 +2703,7 @@ namespace Catch {
});
BenchmarkInfo info {
- name,
+ CATCH_MOVE(name),
plan.estimated_duration.count(),
plan.iterations_per_sample,
cfg->benchmarkSamples(),
@@ -2625,7 +2719,7 @@ namespace Catch {
});
auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
- BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+ BenchmarkStats<FloatDuration<Clock>> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
getResultCapture().benchmarkEnded(stats);
} CATCH_CATCH_ANON (TestFailureException) {
getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
@@ -2737,14 +2831,18 @@ namespace Catch {
template <typename U>
void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
- T& stored_object() {
- return *static_cast<T*>(static_cast<void*>(data));
- }
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+ T& stored_object() { return *reinterpret_cast<T*>( data ); }
T const& stored_object() const {
- return *static_cast<T const*>(static_cast<void const*>(data));
+ return *reinterpret_cast<T const*>( data );
}
-
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+# pragma GCC diagnostic pop
+#endif
alignas( T ) unsigned char data[sizeof( T )]{};
};
@@ -2776,7 +2874,6 @@ namespace Catch {
#include <cstddef>
#include <type_traits>
#include <string>
-#include <string.h>
@@ -2939,6 +3036,13 @@ namespace Catch {
namespace Detail {
+ inline std::size_t catch_strnlen(const char *str, std::size_t n) {
+ auto ret = std::char_traits<char>::find(str, n, '\0');
+ if (ret != nullptr) {
+ return static_cast<std::size_t>(ret - str);
+ }
+ return n;
+ }
constexpr StringRef unprintableString = "{?}"_sr;
@@ -3106,28 +3210,24 @@ namespace Catch {
template<size_t SZ>
struct StringMaker<char[SZ]> {
static std::string convert(char const* str) {
- // Note that `strnlen` is not actually part of standard C++,
- // but both POSIX and Windows cstdlib provide it.
return Detail::convertIntoString(
- StringRef( str, strnlen( str, SZ ) ) );
+ StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
}
};
template<size_t SZ>
struct StringMaker<signed char[SZ]> {
static std::string convert(signed char const* str) {
- // See the plain `char const*` overload
auto reinterpreted = reinterpret_cast<char const*>(str);
return Detail::convertIntoString(
- StringRef(reinterpreted, strnlen(reinterpreted, SZ)));
+ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
}
};
template<size_t SZ>
struct StringMaker<unsigned char[SZ]> {
static std::string convert(unsigned char const* str) {
- // See the plain `char const*` overload
auto reinterpreted = reinterpret_cast<char const*>(str);
return Detail::convertIntoString(
- StringRef(reinterpreted, strnlen(reinterpreted, SZ)));
+ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
}
};
@@ -3194,13 +3294,13 @@ namespace Catch {
template<>
struct StringMaker<float> {
static std::string convert(float value);
- static int precision;
+ CATCH_EXPORT static int precision;
};
template<>
struct StringMaker<double> {
static std::string convert(double value);
- static int precision;
+ CATCH_EXPORT static int precision;
};
template <typename T>
@@ -3739,6 +3839,7 @@ namespace Catch
#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+#include <iosfwd>
#include <string>
#include <vector>
@@ -3757,6 +3858,14 @@ namespace Catch {
virtual bool matches( TestCaseInfo const& testCase ) const = 0;
std::string const& name() const;
private:
+ virtual void serializeTo( std::ostream& out ) const = 0;
+ // Writes string that would be reparsed into the pattern
+ friend std::ostream& operator<<(std::ostream& out,
+ Pattern const& pattern) {
+ pattern.serializeTo( out );
+ return out;
+ }
+
std::string const m_name;
};
@@ -3765,6 +3874,8 @@ namespace Catch {
explicit NamePattern( std::string const& name, std::string const& filterString );
bool matches( TestCaseInfo const& testCase ) const override;
private:
+ void serializeTo( std::ostream& out ) const override;
+
WildcardPattern m_wildcardPattern;
};
@@ -3773,6 +3884,8 @@ namespace Catch {
explicit TagPattern( std::string const& tag, std::string const& filterString );
bool matches( TestCaseInfo const& testCase ) const override;
private:
+ void serializeTo( std::ostream& out ) const override;
+
std::string m_tag;
};
@@ -3780,10 +3893,19 @@ namespace Catch {
std::vector<Detail::unique_ptr<Pattern>> m_required;
std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
+ //! Serializes this filter into a string that would be parsed into
+ //! an equivalent filter
+ void serializeTo( std::ostream& out ) const;
+ friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
+ f.serializeTo( out );
+ return out;
+ }
+
bool matches( TestCaseInfo const& testCase ) const;
- std::string name() const;
};
+ static std::string extractFilterName( Filter const& filter );
+
public:
struct FilterMatch {
std::string name;
@@ -3800,7 +3922,16 @@ namespace Catch {
private:
std::vector<Filter> m_filters;
std::vector<std::string> m_invalidSpecs;
+
friend class TestSpecParser;
+ //! Serializes this test spec into a string that would be parsed into
+ //! equivalent test spec
+ void serializeTo( std::ostream& out ) const;
+ friend std::ostream& operator<<(std::ostream& out,
+ TestSpec const& spec) {
+ spec.serializeTo( out );
+ return out;
+ }
};
}
@@ -3973,6 +4104,7 @@ namespace Catch {
Error = BrightRed,
Success = Green,
+ Skip = LightGrey,
OriginalExpression = Cyan,
ReconstructedExpression = BrightYellow,
@@ -4261,6 +4393,9 @@ namespace Catch {
std::chrono::milliseconds benchmarkWarmupTime() const override;
private:
+ // Reads Bazel env vars and applies them to the config
+ void readBazelEnvVars();
+
ConfigData m_data;
std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
TestSpec m_testSpec;
@@ -4271,6 +4406,19 @@ namespace Catch {
#endif // CATCH_CONFIG_HPP_INCLUDED
+#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+ //! Returns Catch2's current RNG seed.
+ std::uint32_t getSeed();
+}
+
+#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+
#ifndef CATCH_MESSAGE_HPP_INCLUDED
#define CATCH_MESSAGE_HPP_INCLUDED
@@ -4323,11 +4471,10 @@ namespace Catch {
ResultWas::OfType type ):
m_info(macroName, lineInfo, type) {}
-
template<typename T>
- MessageBuilder& operator << ( T const& value ) {
+ MessageBuilder&& operator << ( T const& value ) && {
m_stream << value;
- return *this;
+ return CATCH_MOVE(*this);
}
MessageInfo m_info;
@@ -4335,7 +4482,7 @@ namespace Catch {
class ScopedMessage {
public:
- explicit ScopedMessage( MessageBuilder const& builder );
+ explicit ScopedMessage( MessageBuilder&& builder );
ScopedMessage( ScopedMessage& duplicate ) = delete;
ScopedMessage( ScopedMessage&& old ) noexcept;
~ScopedMessage();
@@ -4382,12 +4529,15 @@ namespace Catch {
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
- Catch::Capturer varName( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+ Catch::Capturer varName( macroName##_catch_sr, \
+ CATCH_INTERNAL_LINEINFO, \
+ Catch::ResultWas::Info, \
+ #__VA_ARGS__##_catch_sr ); \
varName.captureValues( 0, __VA_ARGS__ )
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_INFO( macroName, log ) \
- Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+ const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
@@ -5249,25 +5399,134 @@ namespace Catch {
-#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
-#define CATCH_TEST_MACROS_HPP_INCLUDED
+#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
+#define CATCH_TEST_MACROS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
+#define CATCH_DECOMPOSER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
+#define CATCH_COMPARE_TRAITS_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Detail {
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+# pragma GCC diagnostic push
+ // GCC likes to complain about comparing bool with 0, in the decltype()
+ // that defines the comparable traits below.
+# pragma GCC diagnostic ignored "-Wbool-compare"
+ // "ordered comparison of pointer with integer zero" same as above,
+ // but it does not have a separate warning flag to suppress
+# pragma GCC diagnostic ignored "-Wextra"
+ // Did you know that comparing floats with `0` directly
+ // is super-duper dangerous in unevaluated context?
+# pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+#if defined( __clang__ )
+# pragma clang diagnostic push
+ // Did you know that comparing floats with `0` directly
+ // is super-duper dangerous in unevaluated context?
+# pragma clang diagnostic ignored "-Wfloat-equal"
+#endif
+
+#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op ) \
+ template <typename, typename, typename = void> \
+ struct is_##id##_comparable : std::false_type {}; \
+ template <typename T, typename U> \
+ struct is_##id##_comparable< \
+ T, \
+ U, \
+ void_t<decltype( std::declval<T>() op std::declval<U>() )>> \
+ : std::true_type {}; \
+ template <typename, typename = void> \
+ struct is_##id##_0_comparable : std::false_type {}; \
+ template <typename T> \
+ struct is_##id##_0_comparable<T, \
+ void_t<decltype( std::declval<T>() op 0 )>> \
+ : std::true_type {};
+
+ // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
+ CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
+ CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
+ CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
+ CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
+ CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
+ CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )
+
+#undef CATCH_DEFINE_COMPARABLE_TRAIT
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+# pragma GCC diagnostic pop
+#endif
+#if defined( __clang__ )
+# pragma clang diagnostic pop
+#endif
+
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED
+
+#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+#include <type_traits>
-#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
-#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+namespace Catch {
+namespace Detail {
+#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
+ using std::conjunction;
+ using std::disjunction;
+ using std::negation;
-#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
-#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+#else
+ template <class...> struct conjunction : std::true_type {};
+ template <class B1> struct conjunction<B1> : B1 {};
+ template <class B1, class... Bn>
+ struct conjunction<B1, Bn...>
+ : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
+ template <class...> struct disjunction : std::false_type {};
+ template <class B1> struct disjunction<B1> : B1 {};
+ template <class B1, class... Bn>
+ struct disjunction<B1, Bn...>
+ : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
-#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
-#define CATCH_DECOMPOSER_HPP_INCLUDED
+ template <class B>
+ struct negation : std::integral_constant<bool, !bool(B::value)> {};
+
+#endif
+
+} // namespace Detail
+} // namespace Catch
+#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+#include <type_traits>
#include <iosfwd>
#ifdef _MSC_VER
@@ -5289,6 +5548,9 @@ namespace Catch {
namespace Catch {
+ template <typename T>
+ struct always_false : std::false_type {};
+
class ITransientExpression {
bool m_isBinaryExpression;
bool m_result;
@@ -5411,68 +5673,134 @@ namespace Catch {
};
- // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
- template<typename LhsT, typename RhsT>
- auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
- template<typename T>
- auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
- template<typename T>
- auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
- template<typename LhsT, typename RhsT>
- auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
- template<typename T>
- auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
- template<typename T>
- auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-
template<typename LhsT>
class ExprLhs {
LhsT m_lhs;
public:
explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
- template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
- friend auto operator == ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
- return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
- }
- template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
- friend auto operator == ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
- return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
- }
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op ) \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ Detail::negation<std::is_arithmetic< \
+ std::remove_reference_t<RhsT>>>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ std::is_arithmetic<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_eq_0_comparable<LhsT>, \
+ /* We allow long because we want `ptr op NULL` to be accepted */ \
+ Detail::disjunction<std::is_same<RhsT, int>, \
+ std::is_same<RhsT, long>>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+ return { \
+ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_eq_0_comparable<RhsT>, \
+ /* We allow long because we want `ptr op NULL` to be accepted */ \
+ Detail::disjunction<std::is_same<LhsT, int>, \
+ std::is_same<LhsT, long>>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
- template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
- friend auto operator != ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
- return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
- }
- template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
- friend auto operator != ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
- return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
- }
+ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )
+
+ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op ) \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ Detail::negation<std::is_arithmetic< \
+ std::remove_reference_t<RhsT>>>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ std::is_arithmetic<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_##id##_0_comparable<LhsT>, \
+ std::is_same<RhsT, int>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+ return { \
+ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_##id##_0_comparable<RhsT>, \
+ std::is_same<LhsT, int>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
- #define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(op) \
- template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0> \
- friend auto operator op ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> { \
- return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
- } \
- template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0> \
- friend auto operator op ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> { \
- return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
- }
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )
+
+ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR
+
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op ) \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ ->std::enable_if_t< \
+ !std::is_arithmetic<std::remove_reference_t<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t<std::is_arithmetic<RhsT>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<)
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>)
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<=)
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>=)
CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
@@ -5532,6 +5860,7 @@ namespace Catch {
struct AssertionReaction {
bool shouldDebugBreak = false;
bool shouldThrow = false;
+ bool shouldSkip = false;
};
class AssertionHandler {
@@ -5574,7 +5903,7 @@ namespace Catch {
auto allowThrows() const -> bool;
};
- void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString );
+ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
} // namespace Catch
@@ -5589,9 +5918,9 @@ namespace Catch {
#if !defined(CATCH_CONFIG_DISABLE)
#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
- #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
+ #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
#else
- #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+ #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
#endif
#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
@@ -5642,7 +5971,10 @@ namespace Catch {
do { \
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
} \
catch( ... ) { \
@@ -5657,7 +5989,10 @@ namespace Catch {
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
if( catchAssertionHandler.allowThrows() ) \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( ... ) { \
@@ -5674,7 +6009,10 @@ namespace Catch {
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
if( catchAssertionHandler.allowThrows() ) \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(expr); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( exceptionType const& ) { \
@@ -5697,11 +6035,14 @@ namespace Catch {
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
if( catchAssertionHandler.allowThrows() ) \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( ... ) { \
- Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+ Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
} \
else \
catchAssertionHandler.handleThrowingCallSkipped(); \
@@ -5744,6 +6085,9 @@ namespace Catch {
class Section : Detail::NonCopyable {
public:
Section( SectionInfo&& info );
+ Section( SourceLineInfo const& _lineInfo,
+ StringRef _name,
+ const char* const = nullptr );
~Section();
// This indicates whether the section should be executed or not
@@ -5762,7 +6106,7 @@ namespace Catch {
#define INTERNAL_CATCH_SECTION( ... ) \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
- if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+ if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
@@ -5892,7 +6236,7 @@ struct AutoReg : Detail::NonCopyable {
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
- namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+ namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
static void TestName()
#define INTERNAL_CATCH_TESTCASE( ... ) \
@@ -5903,7 +6247,13 @@ struct AutoReg : Detail::NonCopyable {
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
- namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+ namespace { \
+ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+ Catch::makeTestInvoker( &QualifiedMethod ), \
+ CATCH_INTERNAL_LINEINFO, \
+ "&" #QualifiedMethod##_catch_sr, \
+ Catch::NameAndTags{ __VA_ARGS__ } ); \
+ } /* NOLINT */ \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
///////////////////////////////////////////////////////////////////////////////
@@ -5915,7 +6265,11 @@ struct AutoReg : Detail::NonCopyable {
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
void test(); \
}; \
- Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+ Catch::makeTestInvoker( &TestName::test ), \
+ CATCH_INTERNAL_LINEINFO, \
+ #ClassName##_catch_sr, \
+ Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
} \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
void TestName::test()
@@ -5969,6 +6323,7 @@ struct AutoReg : Detail::NonCopyable {
#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -6022,6 +6377,7 @@ struct AutoReg : Detail::NonCopyable {
#define CATCH_FAIL( ... ) (void)(0)
#define CATCH_FAIL_CHECK( ... ) (void)(0)
#define CATCH_SUCCEED( ... ) (void)(0)
+ #define CATCH_SKIP( ... ) (void)(0)
#define CATCH_STATIC_REQUIRE( ... ) (void)(0)
#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
@@ -6066,6 +6422,7 @@ struct AutoReg : Detail::NonCopyable {
#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -6118,6 +6475,7 @@ struct AutoReg : Detail::NonCopyable {
#define FAIL( ... ) (void)(0)
#define FAIL_CHECK( ... ) (void)(0)
#define SUCCEED( ... ) (void)(0)
+ #define SKIP( ... ) (void)(0)
#define STATIC_REQUIRE( ... ) (void)(0)
#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
@@ -6437,6 +6795,7 @@ struct AutoReg : Detail::NonCopyable {
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
@@ -6447,12 +6806,12 @@ struct AutoReg : Detail::NonCopyable {
struct TestName{\
TestName(){\
size_t index = 0; \
- constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
- using expander = size_t[];\
+ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+ using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
(void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
}\
};\
- static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+ static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
return 0;\
}();\
@@ -6483,6 +6842,7 @@ struct AutoReg : Detail::NonCopyable {
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
template<typename TestType> static void TestFuncName(); \
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
@@ -6532,6 +6892,7 @@ struct AutoReg : Detail::NonCopyable {
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
template<typename TestType> static void TestFunc(); \
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
@@ -6541,7 +6902,7 @@ struct AutoReg : Detail::NonCopyable {
void reg_tests() { \
size_t index = 0; \
using expander = size_t[]; \
- (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
} \
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
@@ -6663,6 +7024,7 @@ struct AutoReg : Detail::NonCopyable {
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
template<typename TestType> \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
void test();\
@@ -6675,7 +7037,7 @@ struct AutoReg : Detail::NonCopyable {
void reg_tests(){\
size_t index = 0;\
using expander = size_t[];\
- (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
}\
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
@@ -6803,6 +7165,7 @@ struct AutoReg : Detail::NonCopyable {
+#include <cstdint>
#include <string>
#include <vector>
@@ -7062,8 +7425,8 @@ namespace Catch {
#define CATCH_VERSION_MACROS_HPP_INCLUDED
#define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 1
-#define CATCH_VERSION_PATCH 0
+#define CATCH_VERSION_MINOR 3
+#define CATCH_VERSION_PATCH 2
#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
@@ -7387,37 +7750,47 @@ namespace Detail {
return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
}
- auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+ IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo );
+ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ GeneratorBasePtr&& generator );
template<typename L>
- // Note: The type after -> is weird, because VS2015 cannot parse
- // the expression used in the typedef inside, when it is in
- // return type. Yeah.
- auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+ auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
using UnderlyingType = typename decltype(generatorExpression())::type;
- IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
- if (!tracker.hasGenerator()) {
- tracker.setGenerator(Catch::Detail::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+ IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
+ // Creation of tracker is delayed after generator creation, so
+ // that constructing generator can fail without breaking everything.
+ if (!tracker) {
+ tracker = createGeneratorTracker(
+ generatorName,
+ lineInfo,
+ Catch::Detail::make_unique<Generators<UnderlyingType>>(
+ generatorExpression() ) );
}
- auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+ auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
return generator.get();
}
} // namespace Generators
} // namespace Catch
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)
+
#define GENERATE( ... ) \
- Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
CATCH_INTERNAL_LINEINFO, \
[ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_COPY( ... ) \
- Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
CATCH_INTERNAL_LINEINFO, \
[=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_REF( ... ) \
- Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
CATCH_INTERNAL_LINEINFO, \
[&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
@@ -8220,7 +8593,10 @@ namespace Catch {
#if defined(__i386__) || defined(__x86_64__)
#define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
#elif defined(__aarch64__)
- #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
+ #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
+ #elif defined(__POWERPC__)
+ #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+ : : : "memory","r0","r3","r4" ) /* NOLINT */
#endif
#elif defined(CATCH_PLATFORM_IPHONE)
@@ -8555,6 +8931,154 @@ namespace Catch {
#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+#ifndef CATCH_GETENV_HPP_INCLUDED
+#define CATCH_GETENV_HPP_INCLUDED
+
+namespace Catch {
+namespace Detail {
+
+ //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
+ char const* getEnv(char const* varName);
+
+}
+}
+
+#endif // CATCH_GETENV_HPP_INCLUDED
+
+
+#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
+#define CATCH_IS_PERMUTATION_HPP_INCLUDED
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+ namespace Detail {
+
+ template <typename ForwardIter,
+ typename Sentinel,
+ typename T,
+ typename Comparator>
+ ForwardIter find_sentinel( ForwardIter start,
+ Sentinel sentinel,
+ T const& value,
+ Comparator cmp ) {
+ while ( start != sentinel ) {
+ if ( cmp( *start, value ) ) { break; }
+ ++start;
+ }
+ return start;
+ }
+
+ template <typename ForwardIter,
+ typename Sentinel,
+ typename T,
+ typename Comparator>
+ std::ptrdiff_t count_sentinel( ForwardIter start,
+ Sentinel sentinel,
+ T const& value,
+ Comparator cmp ) {
+ std::ptrdiff_t count = 0;
+ while ( start != sentinel ) {
+ if ( cmp( *start, value ) ) { ++count; }
+ ++start;
+ }
+ return count;
+ }
+
+ template <typename ForwardIter, typename Sentinel>
+ std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
+ std::ptrdiff_t>
+ sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
+ std::ptrdiff_t dist = 0;
+ while ( iter != sentinel ) {
+ ++iter;
+ ++dist;
+ }
+ return dist;
+ }
+
+ template <typename ForwardIter>
+ std::ptrdiff_t sentinel_distance( ForwardIter first,
+ ForwardIter last ) {
+ return std::distance( first, last );
+ }
+
+ template <typename ForwardIter1,
+ typename Sentinel1,
+ typename ForwardIter2,
+ typename Sentinel2,
+ typename Comparator>
+ bool check_element_counts( ForwardIter1 first_1,
+ const Sentinel1 end_1,
+ ForwardIter2 first_2,
+ const Sentinel2 end_2,
+ Comparator cmp ) {
+ auto cursor = first_1;
+ while ( cursor != end_1 ) {
+ if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
+ cursor ) {
+ // we haven't checked this element yet
+ const auto count_in_range_2 =
+ count_sentinel( first_2, end_2, *cursor, cmp );
+ // Not a single instance in 2nd range, so it cannot be a
+ // permutation of 1st range
+ if ( count_in_range_2 == 0 ) { return false; }
+
+ const auto count_in_range_1 =
+ count_sentinel( cursor, end_1, *cursor, cmp );
+ if ( count_in_range_1 != count_in_range_2 ) {
+ return false;
+ }
+ }
+
+ ++cursor;
+ }
+
+ return true;
+ }
+
+ template <typename ForwardIter1,
+ typename Sentinel1,
+ typename ForwardIter2,
+ typename Sentinel2,
+ typename Comparator>
+ bool is_permutation( ForwardIter1 first_1,
+ const Sentinel1 end_1,
+ ForwardIter2 first_2,
+ const Sentinel2 end_2,
+ Comparator cmp ) {
+ // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
+ // TODO: Comparator has to be "both sides", e.g. a == b => b == a
+ // This skips shared prefix of the two ranges
+ while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
+ ++first_1;
+ ++first_2;
+ }
+
+ // We need to handle case where at least one of the ranges has no more elements
+ if (first_1 == end_1 || first_2 == end_2) {
+ return first_1 == end_1 && first_2 == end_2;
+ }
+
+ // pair counting is n**2, so we pay linear walk to compare the sizes first
+ auto dist_1 = sentinel_distance( first_1, end_1 );
+ auto dist_2 = sentinel_distance( first_2, end_2 );
+
+ if (dist_1 != dist_2) { return false; }
+
+ // Since we do not try to handle stronger iterators pair (e.g.
+ // bidir) optimally, the only thing left to do is to check counts in
+ // the remaining ranges.
+ return check_element_counts( first_1, end_1, first_2, end_2, cmp );
+ }
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED
+
+
#ifndef CATCH_ISTREAM_HPP_INCLUDED
#define CATCH_ISTREAM_HPP_INCLUDED
@@ -8763,6 +9287,26 @@ namespace Catch {
#endif // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
+#define CATCH_PARSE_NUMBERS_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+ /**
+ * Parses unsigned int from the input, using provided base
+ *
+ * Effectively a wrapper around std::stoul but with better error checking
+ * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
+ */
+ Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
+}
+
+#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
+
+
#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
@@ -8813,10 +9357,49 @@ namespace TestCaseTracking {
std::string name;
SourceLineInfo location;
- NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+ NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
- return lhs.name == rhs.name
- && lhs.location == rhs.location;
+ // This is a very cheap check that should have a very high hit rate.
+ // If we get to SourceLineInfo::operator==, we will redo it, but the
+ // cost of repeating is trivial at that point (we will be paying
+ // multiple strcmp/memcmps at that point).
+ if ( lhs.location.line != rhs.location.line ) { return false; }
+ return lhs.name == rhs.name && lhs.location == rhs.location;
+ }
+ friend bool operator!=(NameAndLocation const& lhs,
+ NameAndLocation const& rhs) {
+ return !( lhs == rhs );
+ }
+ };
+
+ /**
+ * This is a variant of `NameAndLocation` that does not own the name string
+ *
+ * This avoids extra allocations when trying to locate a tracker by its
+ * name and location, as long as we make sure that trackers only keep
+ * around the owning variant.
+ */
+ struct NameAndLocationRef {
+ StringRef name;
+ SourceLineInfo location;
+
+ constexpr NameAndLocationRef( StringRef name_,
+ SourceLineInfo location_ ):
+ name( name_ ), location( location_ ) {}
+
+ friend bool operator==( NameAndLocation const& lhs,
+ NameAndLocationRef const& rhs ) {
+ // This is a very cheap check that should have a very high hit rate.
+ // If we get to SourceLineInfo::operator==, we will redo it, but the
+ // cost of repeating is trivial at that point (we will be paying
+ // multiple strcmp/memcmps at that point).
+ if ( lhs.location.line != rhs.location.line ) { return false; }
+ return StringRef( lhs.name ) == rhs.name &&
+ lhs.location == rhs.location;
+ }
+ friend bool operator==( NameAndLocationRef const& lhs,
+ NameAndLocation const& rhs ) {
+ return rhs == lhs;
}
};
@@ -8844,8 +9427,8 @@ namespace TestCaseTracking {
CycleState m_runState = NotStarted;
public:
- ITracker( NameAndLocation const& nameAndLoc, ITracker* parent ):
- m_nameAndLocation( nameAndLoc ),
+ ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
+ m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
m_parent( parent )
{}
@@ -8866,7 +9449,9 @@ namespace TestCaseTracking {
//! Returns true if tracker run to completion (successfully or not)
virtual bool isComplete() const = 0;
//! Returns true if tracker run to completion succesfully
- bool isSuccessfullyCompleted() const;
+ bool isSuccessfullyCompleted() const {
+ return m_runState == CompletedSuccessfully;
+ }
//! Returns true if tracker has started but hasn't been completed
bool isOpen() const;
//! Returns true iff tracker has started
@@ -8884,7 +9469,7 @@ namespace TestCaseTracking {
*
* Returns nullptr if not found.
*/
- ITracker* findChild( NameAndLocation const& nameAndLocation );
+ ITracker* findChild( NameAndLocationRef const& nameAndLocation );
//! Have any children been added?
bool hasChildren() const {
return !m_children.empty();
@@ -8925,13 +9510,15 @@ namespace TestCaseTracking {
public:
ITracker& startRun();
- void endRun();
- void startCycle();
+ void startCycle() {
+ m_currentTracker = m_rootTracker.get();
+ m_runState = Executing;
+ }
void completeCycle();
bool completedCycle() const;
- ITracker& currentTracker();
+ ITracker& currentTracker() { return *m_currentTracker; }
void setCurrentTracker( ITracker* tracker );
};
@@ -8941,7 +9528,7 @@ namespace TestCaseTracking {
TrackerContext& m_ctx;
public:
- TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+ TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
bool isComplete() const override;
@@ -8957,22 +9544,26 @@ namespace TestCaseTracking {
class SectionTracker : public TrackerBase {
std::vector<StringRef> m_filters;
- std::string m_trimmed_name;
+ // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
+ // Currently it allocates owns the name, so this is safe. If it is later refactored
+ // to not own the name, the name still has to outlive the `ITracker` parent, so
+ // this should still be safe.
+ StringRef m_trimmed_name;
public:
- SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+ SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
bool isSectionTracker() const override;
bool isComplete() const override;
- static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+ static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );
void tryOpen();
void addInitialFilters( std::vector<std::string> const& filters );
void addNextFilters( std::vector<StringRef> const& filters );
//! Returns filters active in this tracker
- std::vector<StringRef> const& getFilters() const;
+ std::vector<StringRef> const& getFilters() const { return m_filters; }
//! Returns whitespace-trimmed name of the tracked section
StringRef trimmedName() const;
};
@@ -9035,12 +9626,21 @@ namespace Catch {
ResultWas::OfType resultType,
AssertionReaction &reaction ) override;
- bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+ bool sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) override;
- void sectionEnded( SectionEndInfo const& endInfo ) override;
- void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+ void sectionEnded( SectionEndInfo&& endInfo ) override;
+ void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
+
+ IGeneratorTracker*
+ acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) override;
+ IGeneratorTracker* createGeneratorTracker(
+ StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) override;
- auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
void benchmarkPreparing( StringRef name ) override;
void benchmarkStarting( BenchmarkInfo const& info ) override;
@@ -9050,7 +9650,7 @@ namespace Catch {
void pushScopedMessage( MessageInfo const& message ) override;
void popScopedMessage( MessageInfo const& message ) override;
- void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+ void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
std::string getCurrentTestName() const override;
@@ -9122,6 +9722,7 @@ namespace Catch {
#include <cmath>
+#include <algorithm>
namespace Catch {
@@ -9237,6 +9838,7 @@ namespace Catch {
#define CATCH_STRING_MANIP_HPP_INCLUDED
+#include <cstdint>
#include <string>
#include <iosfwd>
#include <vector>
@@ -9467,7 +10069,6 @@ namespace Catch {
}
};
- TestSpec parseTestSpec( std::string const& arg );
} // namespace Catch
@@ -9673,32 +10274,6 @@ namespace Catch {
#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
-#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
-#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
-
-
-#if defined(CATCH_PLATFORM_WINDOWS)
-
-// We might end up with the define made globally through the compiler,
-// and we don't want to trigger warnings for this
-#if !defined(NOMINMAX)
-# define NOMINMAX
-#endif
-#if !defined(WIN32_LEAN_AND_MEAN)
-# define WIN32_LEAN_AND_MEAN
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-#endif // defined(CATCH_PLATFORM_WINDOWS)
-
-#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
-
-
#ifndef CATCH_XMLWRITER_HPP_INCLUDED
#define CATCH_XMLWRITER_HPP_INCLUDED
@@ -9876,13 +10451,11 @@ namespace Catch {
class MatchExpr : public ITransientExpression {
ArgT && m_arg;
MatcherT const& m_matcher;
- StringRef m_matcherString;
public:
- MatchExpr( ArgT && arg, MatcherT const& matcher, StringRef matcherString )
+ MatchExpr( ArgT && arg, MatcherT const& matcher )
: ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
m_arg( CATCH_FORWARD(arg) ),
- m_matcher( matcher ),
- m_matcherString( matcherString )
+ m_matcher( matcher )
{}
void streamReconstructedExpression( std::ostream& os ) const override {
@@ -9899,11 +10472,11 @@ namespace Catch {
using StringMatcher = Matchers::MatcherBase<std::string>;
- void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString );
+ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
template<typename ArgT, typename MatcherT>
- auto makeMatchExpr( ArgT && arg, MatcherT const& matcher, StringRef matcherString ) -> MatchExpr<ArgT, MatcherT> {
- return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher, matcherString );
+ auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
+ return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
}
} // namespace Catch
@@ -9914,7 +10487,7 @@ namespace Catch {
do { \
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
INTERNAL_CATCH_TRY { \
- catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
+ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
} INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
INTERNAL_CATCH_REACT( catchAssertionHandler ) \
} while( false )
@@ -9930,7 +10503,7 @@ namespace Catch {
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( exceptionType const& ex ) { \
- catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
} \
catch( ... ) { \
catchAssertionHandler.handleUnexpectedInflightException(); \
@@ -10190,7 +10763,7 @@ namespace Matchers {
MatcherGenericBase() = default;
~MatcherGenericBase() override; // = default;
- MatcherGenericBase(MatcherGenericBase&) = default;
+ MatcherGenericBase(MatcherGenericBase const&) = default;
MatcherGenericBase(MatcherGenericBase&&) = default;
MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
@@ -10222,20 +10795,6 @@ namespace Matchers {
return arr;
}
-#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
-
- using std::conjunction;
-
-#else // __cpp_lib_logical_traits
-
- template<typename... Cond>
- struct conjunction : std::true_type {};
-
- template<typename Cond, typename... Rest>
- struct conjunction<Cond, Rest...> : std::integral_constant<bool, Cond::value && conjunction<Rest...>::value> {};
-
-#endif // __cpp_lib_logical_traits
-
template<typename T>
using is_generic_matcher = std::is_base_of<
Catch::Matchers::MatcherGenericBase,
@@ -10243,7 +10802,7 @@ namespace Matchers {
>;
template<typename... Ts>
- using are_generic_matchers = conjunction<is_generic_matcher<Ts>...>;
+ using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
template<typename T>
using is_matcher = std::is_base_of<
@@ -10578,13 +11137,11 @@ namespace Catch {
}
template <typename RangeLike>
- bool match(RangeLike&& rng) const {
- using std::begin; using std::end;
-
- return end(rng) != std::find_if(begin(rng), end(rng),
- [&](auto const& elem) {
- return m_eq(elem, m_desired);
- });
+ bool match( RangeLike&& rng ) const {
+ for ( auto&& elem : rng ) {
+ if ( m_eq( elem, m_desired ) ) { return true; }
+ }
+ return false;
}
};
@@ -10636,7 +11193,7 @@ namespace Catch {
/**
* Creates a matcher that checks whether a range contains a specific element.
*
- * Uses `eq` to do the comparisons
+ * Uses `eq` to do the comparisons, the element is provided on the rhs
*/
template <typename T, typename Equality>
ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
@@ -10672,6 +11229,32 @@ public:
//! Creates a matcher that checks whether a std derived exception has the provided message
ExceptionMessageMatcher Message(std::string const& message);
+template <typename StringMatcherType>
+class ExceptionMessageMatchesMatcher final
+ : public MatcherBase<std::exception> {
+ StringMatcherType m_matcher;
+
+public:
+ ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
+ m_matcher( CATCH_MOVE( matcher ) ) {}
+
+ bool match( std::exception const& ex ) const override {
+ return m_matcher.match( ex.what() );
+ }
+
+ std::string describe() const override {
+ return " matches \"" + m_matcher.describe() + '"';
+ }
+};
+
+//! Creates a matcher that checks whether a message from an std derived
+//! exception matches a provided matcher
+template <typename StringMatcherType>
+ExceptionMessageMatchesMatcher<StringMatcherType>
+MessageMatches( StringMatcherType&& matcher ) {
+ return { CATCH_FORWARD( matcher ) };
+}
+
} // namespace Matchers
} // namespace Catch
@@ -10699,6 +11282,11 @@ namespace Matchers {
double m_margin;
};
+ //! Creates a matcher that accepts numbers within certain range of target
+ WithinAbsMatcher WithinAbs( double target, double margin );
+
+
+
class WithinUlpsMatcher final : public MatcherBase<double> {
public:
WithinUlpsMatcher( double target,
@@ -10712,6 +11300,13 @@ namespace Matchers {
Detail::FloatingPointKind m_type;
};
+ //! Creates a matcher that accepts doubles within certain ULP range of target
+ WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+ //! Creates a matcher that accepts floats within certain ULP range of target
+ WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+
+
+
// Given IEEE-754 format for floats and doubles, we can assume
// that float -> double promotion is lossless. Given this, we can
// assume that if we do the standard relative comparison of
@@ -10728,13 +11323,6 @@ namespace Matchers {
double m_epsilon;
};
- //! Creates a matcher that accepts doubles within certain ULP range of target
- WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
- //! Creates a matcher that accepts floats within certain ULP range of target
- WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
- //! Creates a matcher that accepts numbers within certain range of target
- WithinAbsMatcher WithinAbs(double target, double margin);
-
//! Creates a matcher that accepts doubles within certain relative range of target
WithinRelMatcher WithinRel(double target, double eps);
//! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
@@ -10744,6 +11332,17 @@ namespace Matchers {
//! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
WithinRelMatcher WithinRel(float target);
+
+
+ class IsNaNMatcher final : public MatcherBase<double> {
+ public:
+ IsNaNMatcher() = default;
+ bool match( double const& matchee ) const override;
+ std::string describe() const override;
+ };
+
+ IsNaNMatcher IsNaN();
+
} // namespace Matchers
} // namespace Catch
@@ -10959,6 +11558,143 @@ namespace Catch {
#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <utility>
+
+namespace Catch {
+ namespace Matchers {
+
+ /**
+ * Matcher for checking that an element contains the same
+ * elements in the same order
+ */
+ template <typename TargetRangeLike, typename Equality>
+ class RangeEqualsMatcher final : public MatcherGenericBase {
+ TargetRangeLike m_desired;
+ Equality m_predicate;
+
+ public:
+ template <typename TargetRangeLike2, typename Equality2>
+ RangeEqualsMatcher( TargetRangeLike2&& range,
+ Equality2&& predicate ):
+ m_desired( CATCH_FORWARD( range ) ),
+ m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+ template <typename RangeLike>
+ bool match( RangeLike&& rng ) const {
+ auto rng_start = begin( rng );
+ const auto rng_end = end( rng );
+ auto target_start = begin( m_desired );
+ const auto target_end = end( m_desired );
+
+ while (rng_start != rng_end && target_start != target_end) {
+ if (!m_predicate(*rng_start, *target_start)) {
+ return false;
+ }
+ ++rng_start;
+ ++target_start;
+ }
+ return rng_start == rng_end && target_start == target_end;
+ }
+
+ std::string describe() const override {
+ return "elements are " + Catch::Detail::stringify( m_desired );
+ }
+ };
+
+ /**
+ * Matcher for checking that an element contains the same
+ * elements (but not necessarily in the same order)
+ */
+ template <typename TargetRangeLike, typename Equality>
+ class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
+ TargetRangeLike m_desired;
+ Equality m_predicate;
+
+ public:
+ template <typename TargetRangeLike2, typename Equality2>
+ UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
+ Equality2&& predicate ):
+ m_desired( CATCH_FORWARD( range ) ),
+ m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+ template <typename RangeLike>
+ bool match( RangeLike&& rng ) const {
+ using std::begin;
+ using std::end;
+ return Catch::Detail::is_permutation( begin( m_desired ),
+ end( m_desired ),
+ begin( rng ),
+ end( rng ),
+ m_predicate );
+ }
+
+ std::string describe() const override {
+ return "unordered elements are " +
+ ::Catch::Detail::stringify( m_desired );
+ }
+ };
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range.
+ *
+ * Uses `std::equal_to` to do the comparison
+ */
+ template <typename RangeLike>
+ std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
+ RangeEqualsMatcher<RangeLike, std::equal_to<>>>
+ RangeEquals( RangeLike&& range ) {
+ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range.
+ *
+ * Uses to provided predicate `predicate` to do the comparisons
+ */
+ template <typename RangeLike, typename Equality>
+ RangeEqualsMatcher<RangeLike, Equality>
+ RangeEquals( RangeLike&& range, Equality&& predicate ) {
+ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range, in some permutation
+ *
+ * Uses `std::equal_to` to do the comparison
+ */
+ template <typename RangeLike>
+ std::enable_if_t<
+ !Detail::is_matcher<RangeLike>::value,
+ UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+ UnorderedRangeEquals( RangeLike&& range ) {
+ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range, in some permuation.
+ *
+ * Uses to provided predicate `predicate` to do the comparisons
+ */
+ template <typename RangeLike, typename Equality>
+ UnorderedRangeEqualsMatcher<RangeLike, Equality>
+ UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
+ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+ }
+ } // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+
+
#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
#define CATCH_MATCHERS_STRING_HPP_INCLUDED
@@ -11453,7 +12189,6 @@ namespace Catch {
namespace Catch {
// Fwd decls
- struct SummaryColumn;
class TablePrinter;
class ConsoleReporter final : public StreamingReporterBase {
@@ -11497,12 +12232,7 @@ namespace Catch {
// subsequent lines
void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
- void printTotals(Totals const& totals);
- void printSummaryRow(StringRef label, std::vector<SummaryColumn> const& cols, std::size_t row);
-
void printTotalsDivider(Totals const& totals);
- void printSummaryDivider();
bool m_headerPrinted = false;
bool m_testRunInfoPrinted = false;
@@ -11782,6 +12512,15 @@ namespace Catch {
bool isFiltered,
Verbosity verbosity );
+ /**
+ * Prints test run totals to the provided stream in user-friendly format
+ *
+ * Used by the console and compact reporters.
+ */
+ void printTestRunTotals( std::ostream& stream,
+ ColourImpl& streamColour,
+ Totals const& totals );
+
} // end namespace Catch
#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
@@ -12008,7 +12747,7 @@ namespace Catch {
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
namespace { \
Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
- catch_internal_RegistrarFor )( #listenerType ); \
+ catch_internal_RegistrarFor )( #listenerType##_catch_sr ); \
} \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
@@ -12055,7 +12794,7 @@ namespace Catch {
void writeRun( TestRunNode const& groupNode );
- void writeTestFile(std::string const& filename, std::vector<TestCaseNode const*> const& testCaseNodes);
+ void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);
void writeTestCase(TestCaseNode const& testCaseNode);
diff --git a/packages/Catch2/meson.build b/packages/Catch2/meson.build
new file mode 100644
index 0000000000000000000000000000000000000000..ed5033acd8820752dd3dde09374a13056704c68f
--- /dev/null
+++ b/packages/Catch2/meson.build
@@ -0,0 +1,19 @@
+# Copyright Catch2 Authors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at
+# https://www.boost.org/LICENSE_1_0.txt)
+
+# SPDX-License-Identifier: BSL-1.0
+
+project(
+ 'catch2',
+ 'cpp',
+ version: '3.3.2', # CML version placeholder, don't delete
+ license: 'BSL-1.0',
+ meson_version: '>=0.54.1',
+)
+
+subdir('src/catch2')
+if get_option('tests')
+ subdir('tests')
+endif
diff --git a/packages/Catch2/meson_options.txt b/packages/Catch2/meson_options.txt
new file mode 100644
index 0000000000000000000000000000000000000000..76904873585fc3406b32b6d4e8963eb2dd2fa0a2
--- /dev/null
+++ b/packages/Catch2/meson_options.txt
@@ -0,0 +1 @@
+option('tests', type: 'boolean', value: true, description: 'Build the unit tests')
diff --git a/packages/Catch2/src/CMakeLists.txt b/packages/Catch2/src/CMakeLists.txt
index c76a96d528c1a48a5049474e17c3fe715ae1d2fc..0fdf931e6ee86de3412c1cf7e5aad6c2deaa1a83 100644
--- a/packages/Catch2/src/CMakeLists.txt
+++ b/packages/Catch2/src/CMakeLists.txt
@@ -7,293 +7,338 @@ include(CatchMiscFunctions)
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")
-# Please keep these ordered alphabetically
set(BENCHMARK_HEADERS
- ${SOURCES_DIR}/benchmark/catch_benchmark.hpp
- ${SOURCES_DIR}/benchmark/catch_benchmark_all.hpp
- ${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
+ ${SOURCES_DIR}/benchmark/catch_benchmark.hpp
+ ${SOURCES_DIR}/benchmark/catch_benchmark_all.hpp
+ ${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_benchmark_stats.hpp
+ ${SOURCES_DIR}/benchmark/detail/catch_benchmark_stats_fwd.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
- ${SOURCES_DIR}/benchmark/catch_chronometer.cpp
- ${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.cpp
- ${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.cpp
- ${SOURCES_DIR}/benchmark/detail/catch_stats.cpp
+ ${SOURCES_DIR}/benchmark/catch_chronometer.cpp
+ ${SOURCES_DIR}/benchmark/detail/catch_benchmark_function.cpp
+ ${SOURCES_DIR}/benchmark/detail/catch_run_for_at_least.cpp
+ ${SOURCES_DIR}/benchmark/detail/catch_stats.cpp
)
+set(BENCHMARK_FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})
-SOURCE_GROUP("benchmark" FILES ${BENCHMARK_HEADERS} ${BENCHMARK_SOURCES})
-set(INTERNAL_HEADERS
- "${CMAKE_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
- "${SOURCES_DIR}/catch_user_config.hpp.in"
- ${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
- ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.hpp
- ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.hpp
- ${SOURCES_DIR}/internal/catch_console_width.hpp
- ${SOURCES_DIR}/internal/catch_container_nonmembers.hpp
- ${SOURCES_DIR}/internal/catch_noncopyable.hpp
- ${SOURCES_DIR}/catch_approx.hpp
- ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
- ${SOURCES_DIR}/catch_assertion_info.hpp
- ${SOURCES_DIR}/catch_assertion_result.hpp
- ${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
- ${SOURCES_DIR}/internal/catch_test_failure_exception.hpp
- ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
- ${SOURCES_DIR}/internal/catch_clara.hpp
- ${SOURCES_DIR}/internal/catch_commandline.hpp
- ${SOURCES_DIR}/internal/catch_source_line_info.hpp
- ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
- ${SOURCES_DIR}/catch_config.hpp
- ${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
- ${SOURCES_DIR}/internal/catch_config_counter.hpp
- ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
- ${SOURCES_DIR}/internal/catch_config_wchar.hpp
- ${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
- ${SOURCES_DIR}/internal/catch_fatal_condition_handler.hpp
- ${SOURCES_DIR}/internal/catch_floating_point_helpers.hpp
- ${SOURCES_DIR}/internal/catch_istream.hpp
- ${SOURCES_DIR}/internal/catch_unique_name.hpp
- ${SOURCES_DIR}/internal/catch_sharding.hpp
- ${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
- ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.hpp
- ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_registry.hpp
- ${SOURCES_DIR}/interfaces/catch_interfaces_tag_alias_registry.hpp
- ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.hpp
- ${SOURCES_DIR}/internal/catch_lazy_expr.hpp
- ${SOURCES_DIR}/internal/catch_leak_detector.hpp
- ${SOURCES_DIR}/internal/catch_list.hpp
- ${SOURCES_DIR}/matchers/catch_matchers.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_container_properties.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_contains.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_exception.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_floating_point.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_predicate.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_string.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_templated.hpp
- ${SOURCES_DIR}/matchers/catch_matchers_vector.hpp
- ${SOURCES_DIR}/catch_message.hpp
- ${SOURCES_DIR}/internal/catch_message_info.hpp
- ${SOURCES_DIR}/internal/catch_meta.hpp
- ${SOURCES_DIR}/internal/catch_move_and_forward.hpp
- ${SOURCES_DIR}/internal/catch_optional.hpp
- ${SOURCES_DIR}/internal/catch_output_redirect.hpp
- ${SOURCES_DIR}/internal/catch_platform.hpp
- ${SOURCES_DIR}/internal/catch_polyfills.hpp
- ${SOURCES_DIR}/internal/catch_preprocessor.hpp
- ${SOURCES_DIR}/internal/catch_preprocessor_remove_parens.hpp
- ${SOURCES_DIR}/internal/catch_random_number_generator.hpp
- ${SOURCES_DIR}/internal/catch_random_seed_generation.hpp
- ${SOURCES_DIR}/internal/catch_reporter_registry.hpp
- ${SOURCES_DIR}/internal/catch_reporter_spec_parser.hpp
- ${SOURCES_DIR}/internal/catch_result_type.hpp
- ${SOURCES_DIR}/internal/catch_run_context.hpp
- ${SOURCES_DIR}/internal/catch_section.hpp
- ${SOURCES_DIR}/internal/catch_stdstreams.hpp
- ${SOURCES_DIR}/catch_section_info.hpp
- ${SOURCES_DIR}/catch_session.hpp
- ${SOURCES_DIR}/internal/catch_singletons.hpp
- ${SOURCES_DIR}/internal/catch_startup_exception_registry.hpp
- ${SOURCES_DIR}/internal/catch_reusable_string_stream.hpp
- ${SOURCES_DIR}/internal/catch_stream_end_stop.hpp
- ${SOURCES_DIR}/internal/catch_string_manip.hpp
- ${SOURCES_DIR}/internal/catch_stringref.hpp
- ${SOURCES_DIR}/catch_tag_alias.hpp
- ${SOURCES_DIR}/catch_get_random_seed.hpp
- ${SOURCES_DIR}/catch_tag_alias_autoregistrar.hpp
- ${SOURCES_DIR}/internal/catch_tag_alias_registry.hpp
- ${SOURCES_DIR}/catch_test_case_info.hpp
- ${SOURCES_DIR}/internal/catch_test_case_registry_impl.hpp
- ${SOURCES_DIR}/internal/catch_test_case_tracker.hpp
- ${SOURCES_DIR}/catch_template_test_macros.hpp
- ${SOURCES_DIR}/catch_test_macros.hpp
- ${SOURCES_DIR}/internal/catch_template_test_registry.hpp
- ${SOURCES_DIR}/internal/catch_test_registry.hpp
- ${SOURCES_DIR}/catch_test_spec.hpp
- ${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
- ${SOURCES_DIR}/internal/catch_textflow.hpp
- ${SOURCES_DIR}/catch_timer.hpp
- ${SOURCES_DIR}/internal/catch_to_string.hpp
- ${SOURCES_DIR}/catch_tostring.hpp
- ${SOURCES_DIR}/catch_totals.hpp
- ${SOURCES_DIR}/catch_translate_exception.hpp
- ${SOURCES_DIR}/internal/catch_uncaught_exceptions.hpp
- ${SOURCES_DIR}/internal/catch_unique_ptr.hpp
- ${SOURCES_DIR}/internal/catch_void_type.hpp
- ${SOURCES_DIR}/catch_version.hpp
- ${SOURCES_DIR}/catch_version_macros.hpp
- ${SOURCES_DIR}/internal/catch_wildcard_pattern.hpp
- ${SOURCES_DIR}/internal/catch_windows_h_proxy.hpp
- ${SOURCES_DIR}/internal/catch_xmlwriter.hpp
- ${SOURCES_DIR}/internal/catch_test_case_info_hasher.hpp
+set(IMPL_HEADERS
+ "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
+ ${SOURCES_DIR}/catch_user_config.hpp.in
+ ${SOURCES_DIR}/catch_all.hpp
+ ${SOURCES_DIR}/catch_approx.hpp
+ ${SOURCES_DIR}/catch_assertion_info.hpp
+ ${SOURCES_DIR}/catch_assertion_result.hpp
+ ${SOURCES_DIR}/catch_config.hpp
+ ${SOURCES_DIR}/catch_get_random_seed.hpp
+ ${SOURCES_DIR}/catch_message.hpp
+ ${SOURCES_DIR}/catch_section_info.hpp
+ ${SOURCES_DIR}/catch_session.hpp
+ ${SOURCES_DIR}/catch_tag_alias.hpp
+ ${SOURCES_DIR}/catch_tag_alias_autoregistrar.hpp
+ ${SOURCES_DIR}/catch_template_test_macros.hpp
+ ${SOURCES_DIR}/catch_test_case_info.hpp
+ ${SOURCES_DIR}/catch_test_macros.hpp
+ ${SOURCES_DIR}/catch_test_spec.hpp
+ ${SOURCES_DIR}/catch_timer.hpp
+ ${SOURCES_DIR}/catch_tostring.hpp
+ ${SOURCES_DIR}/catch_totals.hpp
+ ${SOURCES_DIR}/catch_translate_exception.hpp
+ ${SOURCES_DIR}/catch_version.hpp
+ ${SOURCES_DIR}/catch_version_macros.hpp
+ ${SOURCES_DIR}/internal/catch_assertion_handler.hpp
+ ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.hpp
+ ${SOURCES_DIR}/internal/catch_case_sensitive.hpp
+ ${SOURCES_DIR}/internal/catch_clara.hpp
+ ${SOURCES_DIR}/internal/catch_commandline.hpp
+ ${SOURCES_DIR}/internal/catch_compare_traits.hpp
+ ${SOURCES_DIR}/internal/catch_compiler_capabilities.hpp
+ ${SOURCES_DIR}/internal/catch_config_android_logwrite.hpp
+ ${SOURCES_DIR}/internal/catch_config_counter.hpp
+ ${SOURCES_DIR}/internal/catch_config_static_analysis_support.hpp
+ ${SOURCES_DIR}/internal/catch_config_uncaught_exceptions.hpp
+ ${SOURCES_DIR}/internal/catch_config_wchar.hpp
+ ${SOURCES_DIR}/internal/catch_console_colour.hpp
+ ${SOURCES_DIR}/internal/catch_console_width.hpp
+ ${SOURCES_DIR}/internal/catch_container_nonmembers.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
+ ${SOURCES_DIR}/internal/catch_fatal_condition_handler.hpp
+ ${SOURCES_DIR}/internal/catch_floating_point_helpers.hpp
+ ${SOURCES_DIR}/internal/catch_getenv.hpp
+ ${SOURCES_DIR}/internal/catch_istream.hpp
+ ${SOURCES_DIR}/internal/catch_is_permutation.hpp
+ ${SOURCES_DIR}/internal/catch_lazy_expr.hpp
+ ${SOURCES_DIR}/internal/catch_leak_detector.hpp
+ ${SOURCES_DIR}/internal/catch_list.hpp
+ ${SOURCES_DIR}/internal/catch_logical_traits.hpp
+ ${SOURCES_DIR}/internal/catch_message_info.hpp
+ ${SOURCES_DIR}/internal/catch_meta.hpp
+ ${SOURCES_DIR}/internal/catch_move_and_forward.hpp
+ ${SOURCES_DIR}/internal/catch_noncopyable.hpp
+ ${SOURCES_DIR}/internal/catch_optional.hpp
+ ${SOURCES_DIR}/internal/catch_output_redirect.hpp
+ ${SOURCES_DIR}/internal/catch_parse_numbers.hpp
+ ${SOURCES_DIR}/internal/catch_platform.hpp
+ ${SOURCES_DIR}/internal/catch_polyfills.hpp
+ ${SOURCES_DIR}/internal/catch_preprocessor.hpp
+ ${SOURCES_DIR}/internal/catch_preprocessor_remove_parens.hpp
+ ${SOURCES_DIR}/internal/catch_random_number_generator.hpp
+ ${SOURCES_DIR}/internal/catch_random_seed_generation.hpp
+ ${SOURCES_DIR}/internal/catch_reporter_registry.hpp
+ ${SOURCES_DIR}/internal/catch_reporter_spec_parser.hpp
+ ${SOURCES_DIR}/internal/catch_result_type.hpp
+ ${SOURCES_DIR}/internal/catch_reusable_string_stream.hpp
+ ${SOURCES_DIR}/internal/catch_run_context.hpp
+ ${SOURCES_DIR}/internal/catch_section.hpp
+ ${SOURCES_DIR}/internal/catch_sharding.hpp
+ ${SOURCES_DIR}/internal/catch_singletons.hpp
+ ${SOURCES_DIR}/internal/catch_source_line_info.hpp
+ ${SOURCES_DIR}/internal/catch_startup_exception_registry.hpp
+ ${SOURCES_DIR}/internal/catch_stdstreams.hpp
+ ${SOURCES_DIR}/internal/catch_stream_end_stop.hpp
+ ${SOURCES_DIR}/internal/catch_string_manip.hpp
+ ${SOURCES_DIR}/internal/catch_stringref.hpp
+ ${SOURCES_DIR}/internal/catch_tag_alias_registry.hpp
+ ${SOURCES_DIR}/internal/catch_template_test_registry.hpp
+ ${SOURCES_DIR}/internal/catch_test_case_info_hasher.hpp
+ ${SOURCES_DIR}/internal/catch_test_case_registry_impl.hpp
+ ${SOURCES_DIR}/internal/catch_test_case_tracker.hpp
+ ${SOURCES_DIR}/internal/catch_test_failure_exception.hpp
+ ${SOURCES_DIR}/internal/catch_test_macro_impl.hpp
+ ${SOURCES_DIR}/internal/catch_test_registry.hpp
+ ${SOURCES_DIR}/internal/catch_test_run_info.hpp
+ ${SOURCES_DIR}/internal/catch_test_spec_parser.hpp
+ ${SOURCES_DIR}/internal/catch_textflow.hpp
+ ${SOURCES_DIR}/internal/catch_to_string.hpp
+ ${SOURCES_DIR}/internal/catch_uncaught_exceptions.hpp
+ ${SOURCES_DIR}/internal/catch_unique_name.hpp
+ ${SOURCES_DIR}/internal/catch_unique_ptr.hpp
+ ${SOURCES_DIR}/internal/catch_void_type.hpp
+ ${SOURCES_DIR}/internal/catch_wildcard_pattern.hpp
+ ${SOURCES_DIR}/internal/catch_windows_h_proxy.hpp
+ ${SOURCES_DIR}/internal/catch_xmlwriter.hpp
)
set(IMPL_SOURCES
- ${SOURCES_DIR}/catch_approx.cpp
- ${SOURCES_DIR}/internal/catch_assertion_handler.cpp
- ${SOURCES_DIR}/catch_assertion_result.cpp
- ${SOURCES_DIR}/internal/catch_clara.cpp
- ${SOURCES_DIR}/internal/catch_commandline.cpp
- ${SOURCES_DIR}/internal/catch_source_line_info.cpp
- ${SOURCES_DIR}/catch_config.cpp
- ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.cpp
- ${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
- ${SOURCES_DIR}/internal/catch_fatal_condition_handler.cpp
- ${SOURCES_DIR}/internal/catch_floating_point_helpers.cpp
- ${SOURCES_DIR}/internal/catch_istream.cpp
- ${SOURCES_DIR}/interfaces/catch_interfaces_generatortracker.cpp
- ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
- ${SOURCES_DIR}/internal/catch_list.cpp
- ${SOURCES_DIR}/matchers/catch_matchers_floating_point.cpp
- ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.cpp
- ${SOURCES_DIR}/matchers/catch_matchers_string.cpp
- ${SOURCES_DIR}/matchers/catch_matchers_templated.cpp
- ${SOURCES_DIR}/catch_message.cpp
- ${SOURCES_DIR}/internal/catch_output_redirect.cpp
- ${SOURCES_DIR}/catch_registry_hub.cpp
- ${SOURCES_DIR}/internal/catch_random_number_generator.cpp
- ${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
- ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
- ${SOURCES_DIR}/internal/catch_reporter_spec_parser.cpp
- ${SOURCES_DIR}/internal/catch_result_type.cpp
- ${SOURCES_DIR}/internal/catch_run_context.cpp
- ${SOURCES_DIR}/internal/catch_section.cpp
- ${SOURCES_DIR}/internal/catch_stdstreams.cpp
- ${SOURCES_DIR}/catch_session.cpp
- ${SOURCES_DIR}/internal/catch_singletons.cpp
- ${SOURCES_DIR}/internal/catch_reusable_string_stream.cpp
- ${SOURCES_DIR}/internal/catch_stringref.cpp
- ${SOURCES_DIR}/internal/catch_string_manip.cpp
- ${SOURCES_DIR}/internal/catch_tag_alias_registry.cpp
- ${SOURCES_DIR}/catch_test_case_info.cpp
- ${SOURCES_DIR}/internal/catch_test_case_registry_impl.cpp
- ${SOURCES_DIR}/internal/catch_test_case_tracker.cpp
- ${SOURCES_DIR}/internal/catch_test_registry.cpp
- ${SOURCES_DIR}/internal/catch_textflow.cpp
- ${SOURCES_DIR}/catch_test_spec.cpp
- ${SOURCES_DIR}/internal/catch_test_spec_parser.cpp
- ${SOURCES_DIR}/catch_timer.cpp
- ${SOURCES_DIR}/catch_tostring.cpp
- ${SOURCES_DIR}/catch_totals.cpp
- ${SOURCES_DIR}/catch_version.cpp
- ${SOURCES_DIR}/internal/catch_wildcard_pattern.cpp
- ${SOURCES_DIR}/internal/catch_xmlwriter.cpp
- ${SOURCES_DIR}/internal/catch_test_case_info_hasher.cpp
- ${SOURCES_DIR}/generators/catch_generators_random.cpp
- ${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
- ${SOURCES_DIR}/catch_get_random_seed.cpp
- ${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
+ ${SOURCES_DIR}/catch_approx.cpp
+ ${SOURCES_DIR}/catch_assertion_result.cpp
+ ${SOURCES_DIR}/catch_config.cpp
+ ${SOURCES_DIR}/catch_get_random_seed.cpp
+ ${SOURCES_DIR}/catch_message.cpp
+ ${SOURCES_DIR}/catch_registry_hub.cpp
+ ${SOURCES_DIR}/catch_session.cpp
+ ${SOURCES_DIR}/catch_tag_alias_autoregistrar.cpp
+ ${SOURCES_DIR}/catch_test_case_info.cpp
+ ${SOURCES_DIR}/catch_test_spec.cpp
+ ${SOURCES_DIR}/catch_timer.cpp
+ ${SOURCES_DIR}/catch_tostring.cpp
+ ${SOURCES_DIR}/catch_totals.cpp
+ ${SOURCES_DIR}/catch_translate_exception.cpp
+ ${SOURCES_DIR}/catch_version.cpp
+ ${SOURCES_DIR}/internal/catch_assertion_handler.cpp
+ ${SOURCES_DIR}/internal/catch_case_insensitive_comparisons.cpp
+ ${SOURCES_DIR}/internal/catch_clara.cpp
+ ${SOURCES_DIR}/internal/catch_commandline.cpp
+ ${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_decomposer.cpp
+ ${SOURCES_DIR}/internal/catch_enforce.cpp
+ ${SOURCES_DIR}/internal/catch_enum_values_registry.cpp
+ ${SOURCES_DIR}/internal/catch_errno_guard.cpp
+ ${SOURCES_DIR}/internal/catch_exception_translator_registry.cpp
+ ${SOURCES_DIR}/internal/catch_fatal_condition_handler.cpp
+ ${SOURCES_DIR}/internal/catch_floating_point_helpers.cpp
+ ${SOURCES_DIR}/internal/catch_getenv.cpp
+ ${SOURCES_DIR}/internal/catch_istream.cpp
+ ${SOURCES_DIR}/internal/catch_lazy_expr.cpp
+ ${SOURCES_DIR}/internal/catch_leak_detector.cpp
+ ${SOURCES_DIR}/internal/catch_list.cpp
+ ${SOURCES_DIR}/internal/catch_message_info.cpp
+ ${SOURCES_DIR}/internal/catch_output_redirect.cpp
+ ${SOURCES_DIR}/internal/catch_parse_numbers.cpp
+ ${SOURCES_DIR}/internal/catch_polyfills.cpp
+ ${SOURCES_DIR}/internal/catch_random_number_generator.cpp
+ ${SOURCES_DIR}/internal/catch_random_seed_generation.cpp
+ ${SOURCES_DIR}/internal/catch_reporter_registry.cpp
+ ${SOURCES_DIR}/internal/catch_reporter_spec_parser.cpp
+ ${SOURCES_DIR}/internal/catch_result_type.cpp
+ ${SOURCES_DIR}/internal/catch_reusable_string_stream.cpp
+ ${SOURCES_DIR}/internal/catch_run_context.cpp
+ ${SOURCES_DIR}/internal/catch_section.cpp
+ ${SOURCES_DIR}/internal/catch_singletons.cpp
+ ${SOURCES_DIR}/internal/catch_source_line_info.cpp
+ ${SOURCES_DIR}/internal/catch_startup_exception_registry.cpp
+ ${SOURCES_DIR}/internal/catch_stdstreams.cpp
+ ${SOURCES_DIR}/internal/catch_string_manip.cpp
+ ${SOURCES_DIR}/internal/catch_stringref.cpp
+ ${SOURCES_DIR}/internal/catch_tag_alias_registry.cpp
+ ${SOURCES_DIR}/internal/catch_test_case_info_hasher.cpp
+ ${SOURCES_DIR}/internal/catch_test_case_registry_impl.cpp
+ ${SOURCES_DIR}/internal/catch_test_case_tracker.cpp
+ ${SOURCES_DIR}/internal/catch_test_failure_exception.cpp
+ ${SOURCES_DIR}/internal/catch_test_registry.cpp
+ ${SOURCES_DIR}/internal/catch_test_spec_parser.cpp
+ ${SOURCES_DIR}/internal/catch_textflow.cpp
+ ${SOURCES_DIR}/internal/catch_uncaught_exceptions.cpp
+ ${SOURCES_DIR}/internal/catch_wildcard_pattern.cpp
+ ${SOURCES_DIR}/internal/catch_xmlwriter.cpp
)
-set(INTERNAL_FILES ${IMPL_SOURCES} ${INTERNAL_HEADERS})
+set(INTERNAL_FILES ${IMPL_SOURCES} ${IMPL_HEADERS})
+
+set(INTERFACE_HEADERS
+ ${SOURCES_DIR}/interfaces/catch_interfaces_all.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
+ ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.hpp
+ ${SOURCES_DIR}/interfaces/catch_interfaces_tag_alias_registry.hpp
+ ${SOURCES_DIR}/interfaces/catch_interfaces_test_invoker.hpp
+ ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.hpp
+)
+set(INTERFACE_SOURCES
+ ${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_generatortracker.cpp
+ ${SOURCES_DIR}/interfaces/catch_interfaces_registry_hub.cpp
+ ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
+ ${SOURCES_DIR}/interfaces/catch_interfaces_reporter_factory.cpp
+ ${SOURCES_DIR}/interfaces/catch_interfaces_testcase.cpp
+)
+set(INTERFACE_FILES ${INTERFACE_HEADERS} ${INTERFACE_SOURCES})
+
+set(GENERATOR_HEADERS
+ ${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_all.hpp
+ ${SOURCES_DIR}/generators/catch_generators_random.hpp
+ ${SOURCES_DIR}/generators/catch_generators_range.hpp
+)
+set(GENERATOR_SOURCES
+ ${SOURCES_DIR}/generators/catch_generator_exception.cpp
+ ${SOURCES_DIR}/generators/catch_generators.cpp
+ ${SOURCES_DIR}/generators/catch_generators_random.cpp
+)
+set(GENERATOR_FILES ${GENERATOR_HEADERS} ${GENERATOR_SOURCES})
+
+set(MATCHER_HEADERS
+ ${SOURCES_DIR}/matchers/catch_matchers.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_all.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_container_properties.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_contains.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_range_equals.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_exception.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_floating_point.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_predicate.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_string.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_templated.hpp
+ ${SOURCES_DIR}/matchers/catch_matchers_vector.hpp
+ ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.hpp
+)
+set(MATCHER_SOURCES
+ ${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_floating_point.cpp
+ ${SOURCES_DIR}/matchers/catch_matchers_predicate.cpp
+ ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.cpp
+ ${SOURCES_DIR}/matchers/catch_matchers_string.cpp
+ ${SOURCES_DIR}/matchers/catch_matchers_templated.cpp
+ ${SOURCES_DIR}/matchers/internal/catch_matchers_impl.cpp
+)
+set(MATCHER_FILES ${MATCHER_HEADERS} ${MATCHER_SOURCES})
-# Please keep these ordered alphabetically
set(REPORTER_HEADERS
- ${SOURCES_DIR}/reporters/catch_reporters_all.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_automake.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_common_base.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_compact.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_console.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_event_listener.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_helpers.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_junit.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_multi.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_registrars.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_tap.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_teamcity.hpp
- ${SOURCES_DIR}/reporters/catch_reporter_xml.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_automake.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_common_base.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_compact.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_console.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_event_listener.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_helpers.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_junit.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_multi.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_registrars.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_tap.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_teamcity.hpp
+ ${SOURCES_DIR}/reporters/catch_reporter_xml.hpp
+ ${SOURCES_DIR}/reporters/catch_reporters_all.hpp
)
set(REPORTER_SOURCES
- ${SOURCES_DIR}/reporters/catch_reporter_automake.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_common_base.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_compact.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_console.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_event_listener.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_helpers.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_junit.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_multi.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_registrars.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_tap.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_teamcity.cpp
- ${SOURCES_DIR}/reporters/catch_reporter_xml.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_automake.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_common_base.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_compact.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_console.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_cumulative_base.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_event_listener.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_helpers.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_junit.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_multi.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_registrars.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_sonarqube.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_streaming_base.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_tap.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_teamcity.cpp
+ ${SOURCES_DIR}/reporters/catch_reporter_xml.cpp
)
set(REPORTER_FILES ${REPORTER_HEADERS} ${REPORTER_SOURCES})
-add_library(Catch2
+set(ALL_FILES
+ ${BENCHMARK_FILES}
+ ${GENERATOR_FILES}
${REPORTER_FILES}
+ ${INTERFACE_FILES}
${INTERNAL_FILES}
- ${BENCHMARK_HEADERS}
- ${BENCHMARK_SOURCES}
+ ${MATCHER_FILES}
+)
+
+set(FILTERED_FILES ${ALL_FILES})
+list(REMOVE_ITEM FILTERED_FILES "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp")
+source_group(
+ TREE ${SOURCES_DIR}
+ PREFIX sources
+ FILES ${FILTERED_FILES}
+)
+source_group("generated headers"
+ FILES
+ "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
)
+
+add_library(Catch2 ${ALL_FILES})
add_build_reproducibility_settings(Catch2)
add_library(Catch2::Catch2 ALIAS Catch2)
@@ -301,7 +346,10 @@ if (ANDROID)
target_link_libraries(Catch2 INTERFACE log)
endif()
-set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "d")
+set_target_properties(Catch2 PROPERTIES
+ DEBUG_POSTFIX "d"
+ VERSION ${PROJECT_VERSION}
+ SOVERSION ${PROJECT_VERSION})
# depend on bunch of C++11 and C++14 features to have C++14 enabled by default
target_compile_features(Catch2
@@ -330,13 +378,13 @@ target_compile_features(Catch2
configure_file(
"${SOURCES_DIR}/catch_user_config.hpp.in"
- "${CMAKE_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
+ "${PROJECT_BINARY_DIR}/generated-includes/catch2/catch_user_config.hpp"
)
target_include_directories(Catch2
PUBLIC
$<BUILD_INTERFACE:${SOURCES_DIR}/..>
- $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated-includes>
+ $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated-includes>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
@@ -350,6 +398,8 @@ target_link_libraries(Catch2WithMain PUBLIC Catch2)
set_target_properties(Catch2WithMain
PROPERTIES
OUTPUT_NAME "Catch2Main"
+ VERSION ${PROJECT_VERSION}
+ SOVERSION ${PROJECT_VERSION}
)
set_target_properties(Catch2WithMain PROPERTIES DEBUG_POSTFIX "d")
@@ -361,7 +411,7 @@ if (NOT_SUBPROJECT)
Catch2WithMain
EXPORT
Catch2Targets
- LIBRARY DESTINATION
+ LIBRARY DESTINATION
${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION
${CMAKE_INSTALL_LIBDIR}
@@ -382,7 +432,7 @@ if (NOT_SUBPROJECT)
install(
DIRECTORY
"${SOURCES_DIR}"
- "${CMAKE_BINARY_DIR}/generated-includes/catch2" # Also install the generated header
+ "${PROJECT_BINARY_DIR}/generated-includes/catch2" # Also install the generated header
DESTINATION
"${CMAKE_INSTALL_INCLUDEDIR}"
FILES_MATCHING
@@ -396,19 +446,20 @@ endif()
if (CATCH_BUILD_EXAMPLES OR CATCH_BUILD_EXTRA_TESTS)
add_library(Catch2_buildall_interface INTERFACE)
target_sources(Catch2_buildall_interface INTERFACE
- ${REPORTER_FILES}
- ${INTERNAL_FILES}
- ${BENCHMARK_HEADERS}
- ${BENCHMARK_SOURCES}
+ ${ALL_FILES}
# Also include main entry point
${SOURCES_DIR}/internal/catch_main.cpp
)
target_include_directories(Catch2_buildall_interface
INTERFACE
$<BUILD_INTERFACE:${SOURCES_DIR}/..>
- $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/generated-includes>
+ $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated-includes>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
+ target_compile_definitions(Catch2_buildall_interface
+ INTERFACE
+ CATCH_CONFIG_STATIC
+ )
target_compile_features(Catch2_buildall_interface
INTERFACE
cxx_alignas
@@ -442,12 +493,10 @@ set(CATCH_WARNING_TARGETS ${CATCH_WARNING_TARGETS} PARENT_SCOPE)
# 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)
- if (MSVC)
- set_target_properties(Catch2 Catch2WithMain
- PROPERTIES
- WINDOWS_EXPORT_ALL_SYMBOLS ON
- )
- endif()
+ set_target_properties(Catch2 Catch2WithMain
+ PROPERTIES
+ WINDOWS_EXPORT_ALL_SYMBOLS ON
+ )
get_target_property(_VisPreset Catch2 CXX_VISIBILITY_PRESET)
if (NOT MSVC AND _VisPreset STREQUAL "hidden")
diff --git a/packages/Catch2/src/catch2/benchmark/catch_benchmark.hpp b/packages/Catch2/src/catch2/benchmark/catch_benchmark.hpp
index 66e3670f602aef04e237fcc0e4aa02eedf30107e..99d1c9df895afa1c2563a32c28876290c85cd64a 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_benchmark.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_benchmark.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,23 +10,27 @@
#ifndef CATCH_BENCHMARK_HPP_INCLUDED
#define CATCH_BENCHMARK_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/catch_user_config.hpp>
#include <catch2/internal/catch_compiler_capabilities.hpp>
#include <catch2/internal/catch_context.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
-#include <catch2/internal/catch_unique_name.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
-#include <catch2/benchmark/catch_chronometer.hpp>
+#include <catch2/internal/catch_test_failure_exception.hpp>
+#include <catch2/internal/catch_unique_name.hpp>
+#include <catch2/interfaces/catch_interfaces_capture.hpp>
+#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+#include <catch2/benchmark/detail/catch_benchmark_stats.hpp>
#include <catch2/benchmark/catch_clock.hpp>
#include <catch2/benchmark/catch_environment.hpp>
#include <catch2/benchmark/catch_execution_plan.hpp>
#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
#include <catch2/benchmark/detail/catch_analyse.hpp>
#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
#include <algorithm>
+#include <chrono>
+#include <exception>
#include <functional>
#include <string>
#include <vector>
@@ -64,7 +68,7 @@ namespace Catch {
});
BenchmarkInfo info {
- name,
+ CATCH_MOVE(name),
plan.estimated_duration.count(),
plan.iterations_per_sample,
cfg->benchmarkSamples(),
@@ -80,9 +84,9 @@ namespace Catch {
});
auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
- BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+ BenchmarkStats<FloatDuration<Clock>> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
getResultCapture().benchmarkEnded(stats);
- } CATCH_CATCH_ANON (TestFailureException) {
+ } CATCH_CATCH_ANON (TestFailureException const&) {
getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
} CATCH_CATCH_ALL{
getResultCapture().benchmarkFailed(translateActiveException());
diff --git a/packages/Catch2/src/catch2/benchmark/catch_benchmark_all.hpp b/packages/Catch2/src/catch2/benchmark/catch_benchmark_all.hpp
index 913942b395d9becbb7da89d2ac6b1bca81a4895b..56fc7c74cdb0f432519a90c713f06d0504585ae4 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_benchmark_all.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_benchmark_all.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -33,6 +33,8 @@
#include <catch2/benchmark/catch_sample_analysis.hpp>
#include <catch2/benchmark/detail/catch_analyse.hpp>
#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
+#include <catch2/benchmark/detail/catch_benchmark_stats.hpp>
+#include <catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp>
#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
#include <catch2/benchmark/detail/catch_measure.hpp>
diff --git a/packages/Catch2/src/catch2/benchmark/catch_chronometer.cpp b/packages/Catch2/src/catch2/benchmark/catch_chronometer.cpp
index 459a26c7e4fe2b8be52ce0bf6211a9d568448748..92f03c9f65fdd00f5b3a7e1e7bbe008ebad28ed9 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_chronometer.cpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_chronometer.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/catch_chronometer.hpp b/packages/Catch2/src/catch2/benchmark/catch_chronometer.hpp
index 7ef08cef0d5a72b9c8d4508474dd4df7e533263a..c3f813060f989a91e63ee786e5213682e5abee18 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_chronometer.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_chronometer.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -12,7 +12,6 @@
#include <catch2/benchmark/catch_clock.hpp>
#include <catch2/benchmark/catch_optimizer.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
#include <catch2/internal/catch_meta.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
diff --git a/packages/Catch2/src/catch2/benchmark/catch_clock.hpp b/packages/Catch2/src/catch2/benchmark/catch_clock.hpp
index e0cf4aaeb4a4f6a89c327df35a028eccb655cf68..cee46097d0b664954a38caeff026a7d81aa4853c 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_clock.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_clock.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/catch_constructor.hpp b/packages/Catch2/src/catch2/benchmark/catch_constructor.hpp
index 86bbfb00de21dd5f38824533be962a77cf724aad..853bd6c1935d18544ae8025973b5169545092006 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_constructor.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_constructor.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -54,14 +54,18 @@ namespace Catch {
template <typename U>
void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
- T& stored_object() {
- return *static_cast<T*>(static_cast<void*>(data));
- }
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+ T& stored_object() { return *reinterpret_cast<T*>( data ); }
T const& stored_object() const {
- return *static_cast<T const*>(static_cast<void const*>(data));
+ return *reinterpret_cast<T const*>( data );
}
-
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+# pragma GCC diagnostic pop
+#endif
alignas( T ) unsigned char data[sizeof( T )]{};
};
diff --git a/packages/Catch2/src/catch2/benchmark/catch_environment.hpp b/packages/Catch2/src/catch2/benchmark/catch_environment.hpp
index cadd7bc392358f2432eafce76ffe11fd3469f591..de4d77df4f0781da089cd824171e0792848ba302 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_environment.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_environment.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/catch_estimate.hpp b/packages/Catch2/src/catch2/benchmark/catch_estimate.hpp
index 884a4614eaaae43f3f6bfc4fb6ae10aee50214b8..be594a189b482ad7f8c9ed00726647e85292b3ed 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_estimate.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_estimate.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/catch_execution_plan.hpp b/packages/Catch2/src/catch2/benchmark/catch_execution_plan.hpp
index bcb366ce6ab510f24d0092f94aea1cfc8907fe2d..4f60a64677850d1b5d4891bb70db7d26ec469c01 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_execution_plan.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_execution_plan.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -17,8 +17,7 @@
#include <catch2/benchmark/detail/catch_repeat.hpp>
#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
-#include <algorithm>
-#include <iterator>
+#include <vector>
namespace Catch {
namespace Benchmark {
@@ -41,14 +40,17 @@ namespace Catch {
Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
std::vector<FloatDuration<Clock>> times;
- times.reserve(cfg.benchmarkSamples());
- std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+ const auto num_samples = cfg.benchmarkSamples();
+ times.reserve( num_samples );
+ for ( size_t i = 0; i < num_samples; ++i ) {
Detail::ChronometerModel<Clock> model;
- this->benchmark(Chronometer(model, iterations_per_sample));
+ this->benchmark( Chronometer( model, iterations_per_sample ) );
auto sample_time = model.elapsed() - env.clock_cost.mean;
- if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
- return sample_time / iterations_per_sample;
- });
+ if ( sample_time < FloatDuration<Clock>::zero() ) {
+ sample_time = FloatDuration<Clock>::zero();
+ }
+ times.push_back(sample_time / iterations_per_sample);
+ }
return times;
}
};
diff --git a/packages/Catch2/src/catch2/benchmark/catch_optimizer.hpp b/packages/Catch2/src/catch2/benchmark/catch_optimizer.hpp
index b9af3ea1de55707af0601903441a8f9c5784d68e..02cf2073e40856db0e36c2051f0372209dabe83a 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_optimizer.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_optimizer.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,7 +10,7 @@
#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
#define CATCH_OPTIMIZER_HPP_INCLUDED
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
# include <atomic> // atomic_thread_fence
#endif
@@ -32,16 +32,23 @@ namespace Catch {
namespace Detail {
inline void optimizer_barrier() { keep_memory(); }
} // namespace Detail
-#elif defined(_MSC_VER)
+#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
+#if defined(_MSVC_VER)
#pragma optimize("", off)
+#elif defined(__IAR_SYSTEMS_ICC__)
+// For IAR the pragma only affects the following function
+#pragma optimize=disable
+#endif
template <typename T>
inline void keep_memory(T* p) {
// thanks @milleniumbug
*reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
}
// TODO equivalent keep_memory()
+#if defined(_MSVC_VER)
#pragma optimize("", on)
+#endif
namespace Detail {
inline void optimizer_barrier() {
diff --git a/packages/Catch2/src/catch2/benchmark/catch_outlier_classification.hpp b/packages/Catch2/src/catch2/benchmark/catch_outlier_classification.hpp
index 933f045997ae41c2bdafe2dad98825ed0d726613..e31d65d4a24d73c045b9c53f7adff4aaeb4af0c9 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_outlier_classification.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_outlier_classification.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/catch_sample_analysis.hpp b/packages/Catch2/src/catch2/benchmark/catch_sample_analysis.hpp
index 6204aaf1417454c81e130d8a4dbdeec108d06000..97b8fe5083eeceb9c9e7ac76a74cb8a287c281da 100644
--- a/packages/Catch2/src/catch2/benchmark/catch_sample_analysis.hpp
+++ b/packages/Catch2/src/catch2/benchmark/catch_sample_analysis.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,14 +10,11 @@
#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
-#include <catch2/benchmark/catch_clock.hpp>
#include <catch2/benchmark/catch_estimate.hpp>
#include <catch2/benchmark/catch_outlier_classification.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
-#include <algorithm>
#include <vector>
-#include <iterator>
namespace Catch {
namespace Benchmark {
@@ -33,7 +30,9 @@ namespace Catch {
operator SampleAnalysis<Duration2>() const {
std::vector<Duration2> samples2;
samples2.reserve(samples.size());
- std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+ for (auto const& d : samples) {
+ samples2.push_back(Duration2(d));
+ }
return {
CATCH_MOVE(samples2),
mean,
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_analyse.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_analyse.hpp
index 6652f5f4d85fdbeb36bebaa3fc8e92584642a14a..c932ff26a4d1bf0ff1c9364015bb426695916bc1 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_analyse.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_analyse.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,15 +10,12 @@
#ifndef CATCH_ANALYSE_HPP_INCLUDED
#define CATCH_ANALYSE_HPP_INCLUDED
-#include <catch2/benchmark/catch_clock.hpp>
#include <catch2/benchmark/catch_environment.hpp>
#include <catch2/benchmark/catch_sample_analysis.hpp>
#include <catch2/benchmark/detail/catch_stats.hpp>
#include <catch2/interfaces/catch_interfaces_config.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
-#include <algorithm>
-#include <iterator>
#include <vector>
namespace Catch {
@@ -29,7 +26,9 @@ namespace Catch {
if (!cfg.benchmarkNoAnalysis()) {
std::vector<double> samples;
samples.reserve(static_cast<size_t>(last - first));
- std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+ for (auto current = first; current != last; ++current) {
+ samples.push_back( current->count() );
+ }
auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
@@ -44,7 +43,10 @@ namespace Catch {
};
std::vector<Duration> samples2;
samples2.reserve(samples.size());
- std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+ for (auto s : samples) {
+ samples2.push_back( Duration( s ) );
+ }
+
return {
CATCH_MOVE(samples2),
wrap_estimate(analysis.mean),
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.cpp b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.cpp
index 9562d29e7c9bf1509c045c841ae7be98399bb8e0..b437d04929f9e4f3b53b7a453c27f94c600da5d5 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.cpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.hpp
index 655c863508fcaa911d776f46dff161125d9da05b..144e4b6e4374ff7f0034fe377d9c995865c8b43a 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_function.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,7 +11,6 @@
#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
#include <catch2/benchmark/catch_chronometer.hpp>
-#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
#include <catch2/internal/catch_meta.hpp>
#include <catch2/internal/catch_unique_ptr.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_stats.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_stats.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a8b3494e97b35a5a36d866911a6fd80a1109200b
--- /dev/null
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_stats.hpp
@@ -0,0 +1,64 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED
+#define CATCH_BENCHMARK_STATS_HPP_INCLUDED
+
+#include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/benchmark/catch_estimate.hpp>
+#include <catch2/benchmark/catch_outlier_classification.hpp>
+// The fwd decl & default specialization needs to be seen by VS2017 before
+// BenchmarkStats itself, or VS2017 will report compilation error.
+#include <catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp>
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ struct BenchmarkInfo {
+ std::string name;
+ double estimatedDuration;
+ int iterations;
+ unsigned int samples;
+ unsigned int resamples;
+ double clockResolution;
+ double clockCost;
+ };
+
+ template <class Duration>
+ struct BenchmarkStats {
+ BenchmarkInfo info;
+
+ std::vector<Duration> samples;
+ Benchmark::Estimate<Duration> mean;
+ Benchmark::Estimate<Duration> standardDeviation;
+ Benchmark::OutlierClassification outliers;
+ double outlierVariance;
+
+ template <typename Duration2>
+ operator BenchmarkStats<Duration2>() const {
+ std::vector<Duration2> samples2;
+ samples2.reserve(samples.size());
+ for (auto const& sample : samples) {
+ samples2.push_back(Duration2(sample));
+ }
+ return {
+ info,
+ CATCH_MOVE(samples2),
+ mean,
+ standardDeviation,
+ outliers,
+ outlierVariance,
+ };
+ }
+ };
+
+
+} // end namespace Catch
+
+#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..607725613eae5bebacb2115873f63bce97e860f6
--- /dev/null
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp
@@ -0,0 +1,23 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+
+#include <chrono>
+
+namespace Catch {
+
+ // We cannot forward declare the type with default template argument
+ // multiple times, so it is split out into a separate header so that
+ // we can prevent multiple declarations in dependees
+ template <typename Duration = std::chrono::duration<double, std::nano>>
+ struct BenchmarkStats;
+
+} // end namespace Catch
+
+#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_complete_invoke.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_complete_invoke.hpp
index 747b37a9968b302c8deb0c8127bde314be1db214..4dff4b7eb8b02f360f752e271cff6a5efeab53d3 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_complete_invoke.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_complete_invoke.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,14 +10,9 @@
#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
-#include <catch2/internal/catch_test_failure_exception.hpp>
#include <catch2/internal/catch_meta.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
-#include <type_traits>
-
namespace Catch {
namespace Benchmark {
namespace Detail {
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_estimate_clock.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_estimate_clock.hpp
index c392ca4f7e9ea00bbe04cda50f9ff9edb29dcfe0..1e916ae4aca0cb7631f2ff21805a6c3905b0410d 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_estimate_clock.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_estimate_clock.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -19,7 +19,6 @@
#include <catch2/internal/catch_unique_ptr.hpp>
#include <algorithm>
-#include <iterator>
#include <vector>
#include <cmath>
@@ -30,26 +29,29 @@ namespace Catch {
std::vector<double> resolution(int k) {
std::vector<TimePoint<Clock>> times;
times.reserve(static_cast<size_t>(k + 1));
- std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+ for ( int i = 0; i < k + 1; ++i ) {
+ times.push_back( Clock::now() );
+ }
std::vector<double> deltas;
deltas.reserve(static_cast<size_t>(k));
- std::transform(std::next(times.begin()), times.end(), times.begin(),
- std::back_inserter(deltas),
- [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+ for ( size_t idx = 1; idx < times.size(); ++idx ) {
+ deltas.push_back( static_cast<double>(
+ ( times[idx] - times[idx - 1] ).count() ) );
+ }
return deltas;
}
- const auto warmup_iterations = 10000;
- const auto warmup_time = std::chrono::milliseconds(100);
- const auto minimum_ticks = 1000;
- const auto warmup_seed = 10000;
- const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
- const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
- const auto clock_cost_estimation_tick_limit = 100000;
- const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
- const auto clock_cost_estimation_iterations = 10000;
+ constexpr auto warmup_iterations = 10000;
+ constexpr auto warmup_time = std::chrono::milliseconds(100);
+ constexpr auto minimum_ticks = 1000;
+ constexpr auto warmup_seed = 10000;
+ constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+ constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+ constexpr auto clock_cost_estimation_tick_limit = 100000;
+ constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+ constexpr auto clock_cost_estimation_iterations = 10000;
template <typename Clock>
int warmup() {
@@ -84,9 +86,11 @@ namespace Catch {
std::vector<double> times;
int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
times.reserve(static_cast<size_t>(nsamples));
- std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
- return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
- });
+ for ( int s = 0; s < nsamples; ++s ) {
+ times.push_back( static_cast<double>(
+ ( time_clock( r.iterations ) / r.iterations )
+ .count() ) );
+ }
return {
FloatDuration<Clock>(mean(times.begin(), times.end())),
classify_outliers(times.begin(), times.end()),
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_measure.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_measure.hpp
index 739e91e58947d6445ab7f36ab219bdcee86613b4..1a30efabe04b211d4f8e369d0c9675f6775754ac 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_measure.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_measure.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,7 +10,6 @@
#ifndef CATCH_MEASURE_HPP_INCLUDED
#define CATCH_MEASURE_HPP_INCLUDED
-#include <catch2/benchmark/catch_clock.hpp>
#include <catch2/benchmark/detail/catch_complete_invoke.hpp>
#include <catch2/benchmark/detail/catch_timing.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_repeat.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_repeat.hpp
index 360af09b6fa8bb729e792576600105265ed60f4a..08c03373bd729e6a20b77012fd4fd3ab96cb7442 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_repeat.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_repeat.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.cpp b/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.cpp
index 6c246d6a5c537b4110d188fefa158991246b3ee9..3ebdcc05ad20c2be7c8a39a1c5801eb8791e4278 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.cpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.cpp
@@ -1,15 +1,16 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/benchmark/detail/catch_run_for_at_least.hpp>
-#include <exception>
#include <catch2/internal/catch_enforce.hpp>
+#include <exception>
+
namespace Catch {
namespace Benchmark {
namespace Detail {
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.hpp
index 6b2f56e77bc055a4abe55bc7f828ee918bda62d3..976a4b2430518735a8f37849968844fb85bb77fb 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_run_for_at_least.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_stats.cpp b/packages/Catch2/src/catch2/benchmark/detail/catch_stats.cpp
index 023508064ab5d09f64c9076fb1aea5dd919836f2..ea483a3093c6dea4880ca636676228b23f2ae18d 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_stats.cpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_stats.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,7 +13,7 @@
#include <cassert>
#include <cstddef>
-#include <iterator>
+#include <numeric>
#include <random>
@@ -21,117 +21,172 @@
#include <future>
#endif
-namespace {
-
-using Catch::Benchmark::Detail::sample;
-
- template <typename URng, typename Estimator>
- sample resample(URng& rng, unsigned int resamples, std::vector<double>::iterator first, std::vector<double>::iterator last, Estimator& estimator) {
- auto n = static_cast<size_t>(last - first);
- std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
-
- sample out;
- out.reserve(resamples);
- std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
- std::vector<double> resampled;
- resampled.reserve(n);
- std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[static_cast<std::ptrdiff_t>(dist(rng))]; });
- return estimator(resampled.begin(), resampled.end());
- });
- std::sort(out.begin(), out.end());
- return out;
- }
-
-
- double erf_inv(double x) {
- // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
- double w, p;
-
- w = -log((1.0 - x) * (1.0 + x));
-
- if (w < 6.250000) {
- w = w - 3.125000;
- p = -3.6444120640178196996e-21;
- p = -1.685059138182016589e-19 + p * w;
- p = 1.2858480715256400167e-18 + p * w;
- p = 1.115787767802518096e-17 + p * w;
- p = -1.333171662854620906e-16 + p * w;
- p = 2.0972767875968561637e-17 + p * w;
- p = 6.6376381343583238325e-15 + p * w;
- p = -4.0545662729752068639e-14 + p * w;
- p = -8.1519341976054721522e-14 + p * w;
- p = 2.6335093153082322977e-12 + p * w;
- p = -1.2975133253453532498e-11 + p * w;
- p = -5.4154120542946279317e-11 + p * w;
- p = 1.051212273321532285e-09 + p * w;
- p = -4.1126339803469836976e-09 + p * w;
- p = -2.9070369957882005086e-08 + p * w;
- p = 4.2347877827932403518e-07 + p * w;
- p = -1.3654692000834678645e-06 + p * w;
- p = -1.3882523362786468719e-05 + p * w;
- p = 0.0001867342080340571352 + p * w;
- p = -0.00074070253416626697512 + p * w;
- p = -0.0060336708714301490533 + p * w;
- p = 0.24015818242558961693 + p * w;
- p = 1.6536545626831027356 + p * w;
- } else if (w < 16.000000) {
- w = sqrt(w) - 3.250000;
- p = 2.2137376921775787049e-09;
- p = 9.0756561938885390979e-08 + p * w;
- p = -2.7517406297064545428e-07 + p * w;
- p = 1.8239629214389227755e-08 + p * w;
- p = 1.5027403968909827627e-06 + p * w;
- p = -4.013867526981545969e-06 + p * w;
- p = 2.9234449089955446044e-06 + p * w;
- p = 1.2475304481671778723e-05 + p * w;
- p = -4.7318229009055733981e-05 + p * w;
- p = 6.8284851459573175448e-05 + p * w;
- p = 2.4031110387097893999e-05 + p * w;
- p = -0.0003550375203628474796 + p * w;
- p = 0.00095328937973738049703 + p * w;
- p = -0.0016882755560235047313 + p * w;
- p = 0.0024914420961078508066 + p * w;
- p = -0.0037512085075692412107 + p * w;
- p = 0.005370914553590063617 + p * w;
- p = 1.0052589676941592334 + p * w;
- p = 3.0838856104922207635 + p * w;
- } else {
- w = sqrt(w) - 5.000000;
- p = -2.7109920616438573243e-11;
- p = -2.5556418169965252055e-10 + p * w;
- p = 1.5076572693500548083e-09 + p * w;
- p = -3.7894654401267369937e-09 + p * w;
- p = 7.6157012080783393804e-09 + p * w;
- p = -1.4960026627149240478e-08 + p * w;
- p = 2.9147953450901080826e-08 + p * w;
- p = -6.7711997758452339498e-08 + p * w;
- p = 2.2900482228026654717e-07 + p * w;
- p = -9.9298272942317002539e-07 + p * w;
- p = 4.5260625972231537039e-06 + p * w;
- p = -1.9681778105531670567e-05 + p * w;
- p = 7.5995277030017761139e-05 + p * w;
- p = -0.00021503011930044477347 + p * w;
- p = -0.00013871931833623122026 + p * w;
- p = 1.0103004648645343977 + p * w;
- p = 4.8499064014085844221 + p * w;
- }
- return p * x;
- }
-
- double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
- auto m = Catch::Benchmark::Detail::mean(first, last);
- double variance = std::accumulate( first,
- last,
- 0.,
- [m]( double a, double b ) {
- double diff = b - m;
- return a + diff * diff;
- } ) /
- ( last - first );
- return std::sqrt( variance );
- }
-
-}
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ namespace {
+
+ template <typename URng, typename Estimator>
+ static sample
+ resample( URng& rng,
+ unsigned int resamples,
+ std::vector<double>::const_iterator first,
+ std::vector<double>::const_iterator last,
+ Estimator& estimator ) {
+ auto n = static_cast<size_t>( last - first );
+ std::uniform_int_distribution<decltype( n )> dist( 0,
+ n - 1 );
+
+ sample out;
+ out.reserve( resamples );
+ // We allocate the vector outside the loop to avoid realloc
+ // per resample
+ std::vector<double> resampled;
+ resampled.reserve( n );
+ for ( size_t i = 0; i < resamples; ++i ) {
+ resampled.clear();
+ for ( size_t s = 0; s < n; ++s ) {
+ resampled.push_back(
+ first[static_cast<std::ptrdiff_t>(
+ dist( rng ) )] );
+ }
+ const auto estimate =
+ estimator( resampled.begin(), resampled.end() );
+ out.push_back( estimate );
+ }
+ std::sort( out.begin(), out.end() );
+ return out;
+ }
+
+ static double outlier_variance( Estimate<double> mean,
+ Estimate<double> stddev,
+ int n ) {
+ double sb = stddev.point;
+ double mn = mean.point / n;
+ double mg_min = mn / 2.;
+ double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
+ double sg2 = sg * sg;
+ double sb2 = sb * sb;
+
+ auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
+ double k = mn - x;
+ double d = k * k;
+ double nd = n * d;
+ double k0 = -n * nd;
+ double k1 = sb2 - n * sg2 + nd;
+ double det = k1 * k1 - 4 * sg2 * k0;
+ return static_cast<int>( -2. * k0 /
+ ( k1 + std::sqrt( det ) ) );
+ };
+
+ auto var_out = [n, sb2, sg2]( double c ) {
+ double nc = n - c;
+ return ( nc / n ) * ( sb2 - nc * sg2 );
+ };
+
+ return (std::min)( var_out( 1 ),
+ var_out(
+ (std::min)( c_max( 0. ),
+ c_max( mg_min ) ) ) ) /
+ sb2;
+ }
+
+ static double erf_inv( double x ) {
+ // Code accompanying the article "Approximating the erfinv
+ // function" in GPU Computing Gems, Volume 2
+ double w, p;
+
+ w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
+
+ if ( w < 6.250000 ) {
+ w = w - 3.125000;
+ p = -3.6444120640178196996e-21;
+ p = -1.685059138182016589e-19 + p * w;
+ p = 1.2858480715256400167e-18 + p * w;
+ p = 1.115787767802518096e-17 + p * w;
+ p = -1.333171662854620906e-16 + p * w;
+ p = 2.0972767875968561637e-17 + p * w;
+ p = 6.6376381343583238325e-15 + p * w;
+ p = -4.0545662729752068639e-14 + p * w;
+ p = -8.1519341976054721522e-14 + p * w;
+ p = 2.6335093153082322977e-12 + p * w;
+ p = -1.2975133253453532498e-11 + p * w;
+ p = -5.4154120542946279317e-11 + p * w;
+ p = 1.051212273321532285e-09 + p * w;
+ p = -4.1126339803469836976e-09 + p * w;
+ p = -2.9070369957882005086e-08 + p * w;
+ p = 4.2347877827932403518e-07 + p * w;
+ p = -1.3654692000834678645e-06 + p * w;
+ p = -1.3882523362786468719e-05 + p * w;
+ p = 0.0001867342080340571352 + p * w;
+ p = -0.00074070253416626697512 + p * w;
+ p = -0.0060336708714301490533 + p * w;
+ p = 0.24015818242558961693 + p * w;
+ p = 1.6536545626831027356 + p * w;
+ } else if ( w < 16.000000 ) {
+ w = sqrt( w ) - 3.250000;
+ p = 2.2137376921775787049e-09;
+ p = 9.0756561938885390979e-08 + p * w;
+ p = -2.7517406297064545428e-07 + p * w;
+ p = 1.8239629214389227755e-08 + p * w;
+ p = 1.5027403968909827627e-06 + p * w;
+ p = -4.013867526981545969e-06 + p * w;
+ p = 2.9234449089955446044e-06 + p * w;
+ p = 1.2475304481671778723e-05 + p * w;
+ p = -4.7318229009055733981e-05 + p * w;
+ p = 6.8284851459573175448e-05 + p * w;
+ p = 2.4031110387097893999e-05 + p * w;
+ p = -0.0003550375203628474796 + p * w;
+ p = 0.00095328937973738049703 + p * w;
+ p = -0.0016882755560235047313 + p * w;
+ p = 0.0024914420961078508066 + p * w;
+ p = -0.0037512085075692412107 + p * w;
+ p = 0.005370914553590063617 + p * w;
+ p = 1.0052589676941592334 + p * w;
+ p = 3.0838856104922207635 + p * w;
+ } else {
+ w = sqrt( w ) - 5.000000;
+ p = -2.7109920616438573243e-11;
+ p = -2.5556418169965252055e-10 + p * w;
+ p = 1.5076572693500548083e-09 + p * w;
+ p = -3.7894654401267369937e-09 + p * w;
+ p = 7.6157012080783393804e-09 + p * w;
+ p = -1.4960026627149240478e-08 + p * w;
+ p = 2.9147953450901080826e-08 + p * w;
+ p = -6.7711997758452339498e-08 + p * w;
+ p = 2.2900482228026654717e-07 + p * w;
+ p = -9.9298272942317002539e-07 + p * w;
+ p = 4.5260625972231537039e-06 + p * w;
+ p = -1.9681778105531670567e-05 + p * w;
+ p = 7.5995277030017761139e-05 + p * w;
+ p = -0.00021503011930044477347 + p * w;
+ p = -0.00013871931833623122026 + p * w;
+ p = 1.0103004648645343977 + p * w;
+ p = 4.8499064014085844221 + p * w;
+ }
+ return p * x;
+ }
+
+ static double
+ standard_deviation( std::vector<double>::const_iterator first,
+ std::vector<double>::const_iterator last ) {
+ auto m = Catch::Benchmark::Detail::mean( first, last );
+ double variance =
+ std::accumulate( first,
+ last,
+ 0.,
+ [m]( double a, double b ) {
+ double diff = b - m;
+ return a + diff * diff;
+ } ) /
+ ( last - first );
+ return std::sqrt( variance );
+ }
+
+ } // namespace
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
namespace Catch {
namespace Benchmark {
@@ -161,6 +216,47 @@ namespace Catch {
return xj + g * (xj1 - xj);
}
+ OutlierClassification
+ classify_outliers( std::vector<double>::const_iterator first,
+ std::vector<double>::const_iterator last ) {
+ std::vector<double> copy( first, last );
+
+ auto q1 = weighted_average_quantile( 1, 4, copy.begin(), copy.end() );
+ auto q3 = weighted_average_quantile( 3, 4, copy.begin(), copy.end() );
+ auto iqr = q3 - q1;
+ auto los = q1 - ( iqr * 3. );
+ auto lom = q1 - ( iqr * 1.5 );
+ auto him = q3 + ( iqr * 1.5 );
+ auto his = q3 + ( iqr * 3. );
+
+ OutlierClassification o;
+ for ( ; first != last; ++first ) {
+ const double t = *first;
+ if ( t < los ) {
+ ++o.low_severe;
+ } else if ( t < lom ) {
+ ++o.low_mild;
+ } else if ( t > his ) {
+ ++o.high_severe;
+ } else if ( t > him ) {
+ ++o.high_mild;
+ }
+ ++o.samples_seen;
+ }
+ return o;
+ }
+
+ double mean( std::vector<double>::const_iterator first,
+ std::vector<double>::const_iterator last ) {
+ auto count = last - first;
+ double sum = 0.;
+ while (first != last) {
+ sum += *first;
+ ++first;
+ }
+ return sum / static_cast<double>(count);
+ }
+
double erfc_inv(double x) {
return erf_inv(1.0 - x);
@@ -182,35 +278,10 @@ namespace Catch {
return result;
}
-
- double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
- double sb = stddev.point;
- double mn = mean.point / n;
- double mg_min = mn / 2.;
- double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
- double sg2 = sg * sg;
- double sb2 = sb * sb;
-
- auto c_max = [n, mn, sb2, sg2](double x) -> double {
- double k = mn - x;
- double d = k * k;
- double nd = n * d;
- double k0 = -n * nd;
- double k1 = sb2 - n * sg2 + nd;
- double det = k1 * k1 - 4 * sg2 * k0;
- return static_cast<int>(-2. * k0 / (k1 + std::sqrt(det)));
- };
-
- auto var_out = [n, sb2, sg2](double c) {
- double nc = n - c;
- return (nc / n) * (sb2 - nc * sg2);
- };
-
- return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;
- }
-
-
- bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+ bootstrap_analysis analyse_samples(double confidence_level,
+ unsigned int n_resamples,
+ std::vector<double>::iterator first,
+ std::vector<double>::iterator last) {
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
static std::random_device entropy;
@@ -218,11 +289,12 @@ namespace Catch {
auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
- auto mean = &Detail::mean<std::vector<double>::iterator>;
+ auto mean = &Detail::mean;
auto stddev = &standard_deviation;
#if defined(CATCH_CONFIG_USE_ASYNC)
- auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+ auto Estimate = [=](double(*f)(std::vector<double>::const_iterator,
+ std::vector<double>::const_iterator)) {
auto seed = entropy();
return std::async(std::launch::async, [=] {
std::mt19937 rng(seed);
@@ -237,7 +309,8 @@ namespace Catch {
auto mean_estimate = mean_future.get();
auto stddev_estimate = stddev_future.get();
#else
- auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+ auto Estimate = [=](double(*f)(std::vector<double>::const_iterator,
+ std::vector<double>::const_iterator)) {
auto seed = entropy();
std::mt19937 rng(seed);
auto resampled = resample(rng, n_resamples, first, last, f);
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_stats.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_stats.hpp
index bfeace2c127d8ea220b74aca13eeebc5f80d50e7..c1ce56644271cd79c52d96ebf42a0afe0de787a2 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_stats.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_stats.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -15,8 +15,6 @@
#include <algorithm>
#include <vector>
-#include <numeric>
-#include <tuple>
#include <cmath>
namespace Catch {
@@ -30,39 +28,17 @@ namespace Catch {
double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
- template <typename Iterator>
- OutlierClassification classify_outliers(Iterator first, Iterator last) {
- std::vector<double> copy(first, last);
-
- auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
- auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
- auto iqr = q3 - q1;
- auto los = q1 - (iqr * 3.);
- auto lom = q1 - (iqr * 1.5);
- auto him = q3 + (iqr * 1.5);
- auto his = q3 + (iqr * 3.);
-
- OutlierClassification o;
- for (; first != last; ++first) {
- auto&& t = *first;
- if (t < los) ++o.low_severe;
- else if (t < lom) ++o.low_mild;
- else if (t > his) ++o.high_severe;
- else if (t > him) ++o.high_mild;
- ++o.samples_seen;
- }
- return o;
- }
+ OutlierClassification
+ classify_outliers( std::vector<double>::const_iterator first,
+ std::vector<double>::const_iterator last );
- template <typename Iterator>
- double mean(Iterator first, Iterator last) {
- auto count = last - first;
- double sum = std::accumulate(first, last, 0.);
- return sum / static_cast<double>(count);
- }
+ double mean( std::vector<double>::const_iterator first,
+ std::vector<double>::const_iterator last );
- template <typename Estimator, typename Iterator>
- sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+ template <typename Estimator>
+ sample jackknife(Estimator&& estimator,
+ std::vector<double>::iterator first,
+ std::vector<double>::iterator last) {
auto n = static_cast<size_t>(last - first);
auto second = first;
++second;
@@ -85,8 +61,12 @@ namespace Catch {
double normal_quantile(double p);
- template <typename Iterator, typename Estimator>
- Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+ template <typename Estimator>
+ Estimate<double> bootstrap( double confidence_level,
+ std::vector<double>::iterator first,
+ std::vector<double>::iterator last,
+ sample const& resample,
+ Estimator&& estimator ) {
auto n_samples = last - first;
double point = estimator(first, last);
@@ -95,13 +75,13 @@ namespace Catch {
sample jack = jackknife(estimator, first, last);
double jack_mean = mean(jack.begin(), jack.end());
- double sum_squares, sum_cubes;
- std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
- auto d = jack_mean - x;
- auto d2 = d * d;
- auto d3 = d2 * d;
- return { sqcb.first + d2, sqcb.second + d3 };
- });
+ double sum_squares = 0, sum_cubes = 0;
+ for (double x : jack) {
+ auto difference = jack_mean - x;
+ auto square = difference * difference;
+ auto cube = square * difference;
+ sum_squares += square; sum_cubes += cube;
+ }
double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
long n = static_cast<long>(resample.size());
@@ -128,15 +108,16 @@ namespace Catch {
return { point, resample[lo], resample[hi], confidence_level };
}
- double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
-
struct bootstrap_analysis {
Estimate<double> mean;
Estimate<double> standard_deviation;
double outlier_variance;
};
- bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+ bootstrap_analysis analyse_samples(double confidence_level,
+ unsigned int n_resamples,
+ std::vector<double>::iterator first,
+ std::vector<double>::iterator last);
} // namespace Detail
} // namespace Benchmark
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/benchmark/detail/catch_timing.hpp b/packages/Catch2/src/catch2/benchmark/detail/catch_timing.hpp
index 40a9512b7d54ac6643746c0aad72b653a0a80d91..f5c25571c4779a0cf7ac586c427e3d54ef277a62 100644
--- a/packages/Catch2/src/catch2/benchmark/detail/catch_timing.hpp
+++ b/packages/Catch2/src/catch2/benchmark/detail/catch_timing.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_all.hpp b/packages/Catch2/src/catch2/catch_all.hpp
index 94f552237afb5245c4588925d57d18bb20cdd024..70ec402d6c223eb99dd8a005f17b1c04760a6743 100644
--- a/packages/Catch2/src/catch2/catch_all.hpp
+++ b/packages/Catch2/src/catch2/catch_all.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -50,9 +50,11 @@
#include <catch2/internal/catch_case_sensitive.hpp>
#include <catch2/internal/catch_clara.hpp>
#include <catch2/internal/catch_commandline.hpp>
+#include <catch2/internal/catch_compare_traits.hpp>
#include <catch2/internal/catch_compiler_capabilities.hpp>
#include <catch2/internal/catch_config_android_logwrite.hpp>
#include <catch2/internal/catch_config_counter.hpp>
+#include <catch2/internal/catch_config_static_analysis_support.hpp>
#include <catch2/internal/catch_config_uncaught_exceptions.hpp>
#include <catch2/internal/catch_config_wchar.hpp>
#include <catch2/internal/catch_console_colour.hpp>
@@ -68,19 +70,24 @@
#include <catch2/internal/catch_exception_translator_registry.hpp>
#include <catch2/internal/catch_fatal_condition_handler.hpp>
#include <catch2/internal/catch_floating_point_helpers.hpp>
+#include <catch2/internal/catch_getenv.hpp>
+#include <catch2/internal/catch_is_permutation.hpp>
#include <catch2/internal/catch_istream.hpp>
#include <catch2/internal/catch_lazy_expr.hpp>
#include <catch2/internal/catch_leak_detector.hpp>
#include <catch2/internal/catch_list.hpp>
+#include <catch2/internal/catch_logical_traits.hpp>
#include <catch2/internal/catch_message_info.hpp>
#include <catch2/internal/catch_meta.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
#include <catch2/internal/catch_noncopyable.hpp>
#include <catch2/internal/catch_optional.hpp>
#include <catch2/internal/catch_output_redirect.hpp>
+#include <catch2/internal/catch_parse_numbers.hpp>
#include <catch2/internal/catch_platform.hpp>
#include <catch2/internal/catch_polyfills.hpp>
#include <catch2/internal/catch_preprocessor.hpp>
+#include <catch2/internal/catch_preprocessor_internal_stringify.hpp>
#include <catch2/internal/catch_preprocessor_remove_parens.hpp>
#include <catch2/internal/catch_random_number_generator.hpp>
#include <catch2/internal/catch_random_seed_generation.hpp>
@@ -106,6 +113,7 @@
#include <catch2/internal/catch_test_failure_exception.hpp>
#include <catch2/internal/catch_test_macro_impl.hpp>
#include <catch2/internal/catch_test_registry.hpp>
+#include <catch2/internal/catch_test_run_info.hpp>
#include <catch2/internal/catch_test_spec_parser.hpp>
#include <catch2/internal/catch_textflow.hpp>
#include <catch2/internal/catch_to_string.hpp>
@@ -114,7 +122,6 @@
#include <catch2/internal/catch_unique_ptr.hpp>
#include <catch2/internal/catch_void_type.hpp>
#include <catch2/internal/catch_wildcard_pattern.hpp>
-#include <catch2/internal/catch_windows_h_proxy.hpp>
#include <catch2/internal/catch_xmlwriter.hpp>
#include <catch2/matchers/catch_matchers_all.hpp>
#include <catch2/reporters/catch_reporters_all.hpp>
diff --git a/packages/Catch2/src/catch2/catch_approx.cpp b/packages/Catch2/src/catch2/catch_approx.cpp
index b477d6ed985afa4064583d497ed3a550f3f8c555..407586d1d5db4462d5c6bfa5f9b7e49812dcda56 100644
--- a/packages/Catch2/src/catch2/catch_approx.cpp
+++ b/packages/Catch2/src/catch2/catch_approx.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_approx.hpp b/packages/Catch2/src/catch2/catch_approx.hpp
index a46caeb53b49083cd2998498e6ec7d9d54d76cbb..de4d2ab4ca0a6402f559458f8d8c657607332544 100644
--- a/packages/Catch2/src/catch2/catch_approx.hpp
+++ b/packages/Catch2/src/catch2/catch_approx.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_assertion_info.hpp b/packages/Catch2/src/catch2/catch_assertion_info.hpp
index 516c324c5c9720edf7c051470ecb2c2fae666e80..9d2f91fad01f552e8d62e7870a98e470701a0ac6 100644
--- a/packages/Catch2/src/catch2/catch_assertion_info.hpp
+++ b/packages/Catch2/src/catch2/catch_assertion_info.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_assertion_result.cpp b/packages/Catch2/src/catch2/catch_assertion_result.cpp
index 2912c8d305e043aa8f6eae6cc7035a5316cebba3..61d4fd068a92883e9e1edaa454f76d1c24585f00 100644
--- a/packages/Catch2/src/catch2/catch_assertion_result.cpp
+++ b/packages/Catch2/src/catch2/catch_assertion_result.cpp
@@ -1,12 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/catch_assertion_result.hpp>
#include <catch2/internal/catch_reusable_string_stream.hpp>
+#include <catch2/internal/catch_move_and_forward.hpp>
namespace Catch {
@@ -26,9 +27,9 @@ namespace Catch {
return reconstructedExpression;
}
- AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+ AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
: m_info( info ),
- m_resultData( data )
+ m_resultData( CATCH_MOVE(data) )
{}
// Result was a success
@@ -67,16 +68,15 @@ namespace Catch {
}
std::string AssertionResult::getExpressionInMacro() const {
- std::string expr;
- if( m_info.macroName.empty() )
- expr = static_cast<std::string>(m_info.capturedExpression);
- else {
- expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
- expr += m_info.macroName;
- expr += "( ";
- expr += m_info.capturedExpression;
- expr += " )";
+ if ( m_info.macroName.empty() ) {
+ return static_cast<std::string>( m_info.capturedExpression );
}
+ std::string expr;
+ expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+ expr += m_info.macroName;
+ expr += "( ";
+ expr += m_info.capturedExpression;
+ expr += " )";
return expr;
}
diff --git a/packages/Catch2/src/catch2/catch_assertion_result.hpp b/packages/Catch2/src/catch2/catch_assertion_result.hpp
index 3008664c212b3e0cec06a8be23041d4ad7b624dc..48882876bca261e5127fe36ea7354ab4985032cc 100644
--- a/packages/Catch2/src/catch2/catch_assertion_result.hpp
+++ b/packages/Catch2/src/catch2/catch_assertion_result.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -35,7 +35,7 @@ namespace Catch {
class AssertionResult {
public:
AssertionResult() = delete;
- AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+ AssertionResult( AssertionInfo const& info, AssertionResultData&& data );
bool isOk() const;
bool succeeded() const;
diff --git a/packages/Catch2/src/catch2/catch_config.cpp b/packages/Catch2/src/catch2/catch_config.cpp
index 4cb3627db542a2da243b7deb7673a702be3c76ae..34f50f1751634af0c66b0308bf9dfddfe577a2b2 100644
--- a/packages/Catch2/src/catch2/catch_config.cpp
+++ b/packages/Catch2/src/catch2/catch_config.cpp
@@ -1,45 +1,88 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/catch_config.hpp>
#include <catch2/catch_user_config.hpp>
#include <catch2/internal/catch_enforce.hpp>
-#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_parse_numbers.hpp>
+#include <catch2/internal/catch_stdstreams.hpp>
#include <catch2/internal/catch_stringref.hpp>
#include <catch2/internal/catch_string_manip.hpp>
#include <catch2/internal/catch_test_spec_parser.hpp>
#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
+#include <catch2/internal/catch_getenv.hpp>
-namespace {
- bool provideBazelReporterOutput() {
-#if defined(CATCH_CONFIG_BAZEL_SUPPORT)
- return true;
-#elif defined(CATCH_PLATFORM_WINDOWS_UWP)
- // UWP does not support environment variables
- return false;
+#include <fstream>
+
+namespace Catch {
+
+ namespace {
+ static bool enableBazelEnvSupport() {
+#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
+ return true;
#else
+ return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
+#endif
+ }
-# if defined( _MSC_VER )
- // On Windows getenv throws a warning as there is no input validation,
- // since the switch is hardcoded, this should not be an issue.
-# pragma warning( push )
-# pragma warning( disable : 4996 )
-# endif
+ struct bazelShardingOptions {
+ unsigned int shardIndex, shardCount;
+ std::string shardFilePath;
+ };
+
+ static Optional<bazelShardingOptions> readBazelShardingOptions() {
+ const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
+ const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
+ const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
+
+
+ const bool has_all =
+ bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
+ if ( !has_all ) {
+ // We provide nice warning message if the input is
+ // misconfigured.
+ auto warn = []( const char* env_var ) {
+ Catch::cerr()
+ << "Warning: Bazel shard configuration is missing '"
+ << env_var << "'. Shard configuration is skipped.\n";
+ };
+ if ( !bazelShardIndex ) {
+ warn( "TEST_SHARD_INDEX" );
+ }
+ if ( !bazelShardTotal ) {
+ warn( "TEST_TOTAL_SHARDS" );
+ }
+ if ( !bazelShardInfoFile ) {
+ warn( "TEST_SHARD_STATUS_FILE" );
+ }
+ return {};
+ }
- return std::getenv( "BAZEL_TEST" ) != nullptr;
+ auto shardIndex = parseUInt( bazelShardIndex );
+ if ( !shardIndex ) {
+ Catch::cerr()
+ << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
+ << "') as unsigned int.\n";
+ return {};
+ }
+ auto shardTotal = parseUInt( bazelShardTotal );
+ if ( !shardTotal ) {
+ Catch::cerr()
+ << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
+ << bazelShardTotal << "') as unsigned int.\n";
+ return {};
+ }
-# if defined( _MSC_VER )
-# pragma warning( pop )
-# endif
-#endif
- }
-}
+ return bazelShardingOptions{
+ *shardIndex, *shardTotal, bazelShardInfoFile };
+
+ }
+ } // end namespace
-namespace Catch {
bool operator==( ProcessedReporterSpec const& lhs,
ProcessedReporterSpec const& rhs ) {
@@ -62,18 +105,7 @@ namespace Catch {
elem = trim(elem);
}
-
- TestSpecParser parser(ITagAliasRegistry::get());
- if (!m_data.testsOrTags.empty()) {
- m_hasTestFilters = true;
- for (auto const& testOrTags : m_data.testsOrTags) {
- parser.parse(testOrTags);
- }
- }
- m_testSpec = parser.testSpec();
-
-
- // Insert the default reporter if user hasn't asked for a specfic one
+ // Insert the default reporter if user hasn't asked for a specific one
if ( m_data.reporterSpecifications.empty() ) {
m_data.reporterSpecifications.push_back( {
#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
@@ -85,29 +117,21 @@ namespace Catch {
} );
}
-#if !defined(CATCH_PLATFORM_WINDOWS_UWP)
- if(provideBazelReporterOutput()){
- // Register a JUnit reporter for Bazel. Bazel sets an environment
- // variable with the path to XML output. If this file is written to
- // during test, Bazel will not generate a default XML output.
- // This allows the XML output file to contain higher level of detail
- // than what is possible otherwise.
-# if defined( _MSC_VER )
- // On Windows getenv throws a warning as there is no input validation,
- // since the key is hardcoded, this should not be an issue.
-# pragma warning( push )
-# pragma warning( disable : 4996 )
-# endif
- const auto bazelOutputFilePtr = std::getenv( "XML_OUTPUT_FILE" );
-# if defined( _MSC_VER )
-# pragma warning( pop )
-# endif
- if ( bazelOutputFilePtr != nullptr ) {
- m_data.reporterSpecifications.push_back(
- { "junit", std::string( bazelOutputFilePtr ), {}, {} } );
+ if ( enableBazelEnvSupport() ) {
+ readBazelEnvVars();
+ }
+
+ // Bazel support can modify the test specs, so parsing has to happen
+ // after reading Bazel env vars.
+ TestSpecParser parser( ITagAliasRegistry::get() );
+ if ( !m_data.testsOrTags.empty() ) {
+ m_hasTestFilters = true;
+ for ( auto const& testOrTags : m_data.testsOrTags ) {
+ parser.parse( testOrTags );
}
- }
-#endif
+ }
+ m_testSpec = parser.testSpec();
+
// We now fixup the reporter specs to handle default output spec,
// default colour spec, etc
@@ -187,4 +211,37 @@ namespace Catch {
unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+ void Config::readBazelEnvVars() {
+ // Register a JUnit reporter for Bazel. Bazel sets an environment
+ // variable with the path to XML output. If this file is written to
+ // during test, Bazel will not generate a default XML output.
+ // This allows the XML output file to contain higher level of detail
+ // than what is possible otherwise.
+ const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
+
+ if ( bazelOutputFile ) {
+ m_data.reporterSpecifications.push_back(
+ { "junit", std::string( bazelOutputFile ), {}, {} } );
+ }
+
+ const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
+ if ( bazelTestSpec ) {
+ // Presumably the test spec from environment should overwrite
+ // the one we got from CLI (if we got any)
+ m_data.testsOrTags.clear();
+ m_data.testsOrTags.push_back( bazelTestSpec );
+ }
+
+ const auto bazelShardOptions = readBazelShardingOptions();
+ if ( bazelShardOptions ) {
+ std::ofstream f( bazelShardOptions->shardFilePath,
+ std::ios_base::out | std::ios_base::trunc );
+ if ( f.is_open() ) {
+ f << "";
+ m_data.shardIndex = bazelShardOptions->shardIndex;
+ m_data.shardCount = bazelShardOptions->shardCount;
+ }
+ }
+ }
+
} // end namespace Catch
diff --git a/packages/Catch2/src/catch2/catch_config.hpp b/packages/Catch2/src/catch2/catch_config.hpp
index 10df4d64ad5c313f106860205285b604e89d0aa0..784de4aa5bbc6361503e2637574463055fd44810 100644
--- a/packages/Catch2/src/catch2/catch_config.hpp
+++ b/packages/Catch2/src/catch2/catch_config.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -140,6 +140,9 @@ namespace Catch {
std::chrono::milliseconds benchmarkWarmupTime() const override;
private:
+ // Reads Bazel env vars and applies them to the config
+ void readBazelEnvVars();
+
ConfigData m_data;
std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
TestSpec m_testSpec;
diff --git a/packages/Catch2/src/catch2/catch_get_random_seed.cpp b/packages/Catch2/src/catch2/catch_get_random_seed.cpp
index 12a5b6d8c20cfe884a673933c9797217de76ac78..b12251684095436cb4807239aa269c8c4078970c 100644
--- a/packages/Catch2/src/catch2/catch_get_random_seed.cpp
+++ b/packages/Catch2/src/catch2/catch_get_random_seed.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_get_random_seed.hpp b/packages/Catch2/src/catch2/catch_get_random_seed.hpp
index 6df3c3a006b578a2fd8fa3be33467554144b17ce..3ab2a4a1c268818f14470e4c4ef1f900049d175a 100644
--- a/packages/Catch2/src/catch2/catch_get_random_seed.hpp
+++ b/packages/Catch2/src/catch2/catch_get_random_seed.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_message.cpp b/packages/Catch2/src/catch2/catch_message.cpp
index 2ad4aea37ba0ad165c778fb3714306474d63ab59..384f180e55a8a663bcf493d021b63459d3de6165 100644
--- a/packages/Catch2/src/catch2/catch_message.cpp
+++ b/packages/Catch2/src/catch2/catch_message.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -19,8 +19,8 @@ namespace Catch {
////////////////////////////////////////////////////////////////////////////
- ScopedMessage::ScopedMessage( MessageBuilder const& builder ):
- m_info( builder.m_info ) {
+ ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
+ m_info( CATCH_MOVE(builder.m_info) ) {
m_info.message = builder.m_stream.str();
getResultCapture().pushScopedMessage( m_info );
}
@@ -37,7 +37,11 @@ namespace Catch {
}
- Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+ Capturer::Capturer( StringRef macroName,
+ SourceLineInfo const& lineInfo,
+ ResultWas::OfType resultType,
+ StringRef names ):
+ m_resultCapture( getResultCapture() ) {
auto trimmed = [&] (size_t start, size_t end) {
while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
++start;
diff --git a/packages/Catch2/src/catch2/catch_message.hpp b/packages/Catch2/src/catch2/catch_message.hpp
index dac7a21d08cf6496fe7f9d4c147328eb1157608f..b348ac87026143447a4b9cd5b02b991949356e0d 100644
--- a/packages/Catch2/src/catch2/catch_message.hpp
+++ b/packages/Catch2/src/catch2/catch_message.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -12,7 +12,6 @@
#include <catch2/internal/catch_reusable_string_stream.hpp>
#include <catch2/internal/catch_stream_end_stop.hpp>
#include <catch2/internal/catch_message_info.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
#include <catch2/catch_tostring.hpp>
#include <string>
@@ -21,6 +20,7 @@
namespace Catch {
struct SourceLineInfo;
+ class IResultCapture;
struct MessageStream {
@@ -39,11 +39,10 @@ namespace Catch {
ResultWas::OfType type ):
m_info(macroName, lineInfo, type) {}
-
template<typename T>
- MessageBuilder& operator << ( T const& value ) {
+ MessageBuilder&& operator << ( T const& value ) && {
m_stream << value;
- return *this;
+ return CATCH_MOVE(*this);
}
MessageInfo m_info;
@@ -51,7 +50,7 @@ namespace Catch {
class ScopedMessage {
public:
- explicit ScopedMessage( MessageBuilder const& builder );
+ explicit ScopedMessage( MessageBuilder&& builder );
ScopedMessage( ScopedMessage& duplicate ) = delete;
ScopedMessage( ScopedMessage&& old ) noexcept;
~ScopedMessage();
@@ -62,7 +61,7 @@ namespace Catch {
class Capturer {
std::vector<MessageInfo> m_messages;
- IResultCapture& m_resultCapture = getResultCapture();
+ IResultCapture& m_resultCapture;
size_t m_captured = 0;
public:
Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
@@ -98,12 +97,15 @@ namespace Catch {
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
- Catch::Capturer varName( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+ Catch::Capturer varName( macroName##_catch_sr, \
+ CATCH_INTERNAL_LINEINFO, \
+ Catch::ResultWas::Info, \
+ #__VA_ARGS__##_catch_sr ); \
varName.captureValues( 0, __VA_ARGS__ )
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_INFO( macroName, log ) \
- Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+ const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
diff --git a/packages/Catch2/src/catch2/catch_registry_hub.cpp b/packages/Catch2/src/catch2/catch_registry_hub.cpp
index 1fca78fb7fa16729353ce34315f6e932f347506e..8716db3a7d28ae88dde6e55c08e42c78dbbdff36 100644
--- a/packages/Catch2/src/catch2/catch_registry_hub.cpp
+++ b/packages/Catch2/src/catch2/catch_registry_hub.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -20,6 +20,9 @@
#include <catch2/internal/catch_noncopyable.hpp>
#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
+
+#include <exception>
namespace Catch {
@@ -31,7 +34,7 @@ namespace Catch {
public: // IRegistryHub
RegistryHub() = default;
- IReporterRegistry const& getReporterRegistry() const override {
+ ReporterRegistry const& getReporterRegistry() const override {
return m_reporterRegistry;
}
ITestCaseRegistry const& getTestCaseRegistry() const override {
diff --git a/packages/Catch2/src/catch2/catch_section_info.hpp b/packages/Catch2/src/catch2/catch_section_info.hpp
index 1d206891d0d293dc9ec9b7c3de8851d0faa8859b..7de8441c5ff968c70fef59b76912a5efeab170f7 100644
--- a/packages/Catch2/src/catch2/catch_section_info.hpp
+++ b/packages/Catch2/src/catch2/catch_section_info.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_session.cpp b/packages/Catch2/src/catch2/catch_session.cpp
index df92559b58392c617c974114f8335b0008ae0bad..f1ed5f9cc55a03d0fd6a7afba2b461a60f8d0bf9 100644
--- a/packages/Catch2/src/catch2/catch_session.cpp
+++ b/packages/Catch2/src/catch2/catch_session.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,13 +13,13 @@
#include <catch2/internal/catch_run_context.hpp>
#include <catch2/catch_test_spec.hpp>
#include <catch2/catch_version.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/internal/catch_startup_exception_registry.hpp>
#include <catch2/internal/catch_sharding.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
#include <catch2/internal/catch_textflow.hpp>
#include <catch2/internal/catch_windows_h_proxy.hpp>
#include <catch2/reporters/catch_reporter_multi.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
#include <catch2/internal/catch_stdstreams.hpp>
@@ -27,6 +27,7 @@
#include <algorithm>
#include <cassert>
+#include <exception>
#include <iomanip>
#include <set>
@@ -61,7 +62,6 @@ namespace Catch {
multi->addListener(listener->create(config));
}
- std::size_t reporterIdx = 0;
for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
multi->addReporter( createReporter(
reporterSpec.name,
@@ -69,7 +69,6 @@ namespace Catch {
makeStream( reporterSpec.outputFilename ),
reporterSpec.colourMode,
reporterSpec.customOptions ) ) );
- reporterIdx++;
}
return multi;
@@ -343,6 +342,12 @@ namespace Catch {
return 2;
}
+ if ( totals.testCases.total() > 0 &&
+ totals.testCases.total() == totals.testCases.skipped
+ && !m_config->zeroTestsCountAsSuccess() ) {
+ return 4;
+ }
+
// Note that on unices only the lower 8 bits are usually used, clamping
// the return value to 255 prevents false negative when some multiple
// of 256 tests has failed
diff --git a/packages/Catch2/src/catch2/catch_session.hpp b/packages/Catch2/src/catch2/catch_session.hpp
index b2d3eb0bce288b7f1857d0a058c76cb27740e0bd..c1de6d5747f2f39322c95d14e89645cc9f962c54 100644
--- a/packages/Catch2/src/catch2/catch_session.hpp
+++ b/packages/Catch2/src/catch2/catch_session.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_tag_alias.hpp b/packages/Catch2/src/catch2/catch_tag_alias.hpp
index d566d70cb7025c2931a905830635fa57458cd746..dc91f21a7686e7937ecb992ba904128db718baa8 100644
--- a/packages/Catch2/src/catch2/catch_tag_alias.hpp
+++ b/packages/Catch2/src/catch2/catch_tag_alias.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.cpp b/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.cpp
index d3e10cb06df83ce2cb5219582be67d1ec5e8992a..9b6633a2f9f276f8edeed32f0caf5254b6cc0d0e 100644
--- a/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.cpp
+++ b/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.hpp b/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.hpp
index c742bcd3bc0f8f3d06b6fc6b60cae446e7403cad..9f80f72fd62827ed1a495d53a631edb7165f004d 100644
--- a/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.hpp
+++ b/packages/Catch2/src/catch2/catch_tag_alias_autoregistrar.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_template_test_macros.hpp b/packages/Catch2/src/catch2/catch_template_test_macros.hpp
index 66b1bc4de2d51251d52b84c8772256a93c09b50c..3baee517537155a972b8c59235ee1340e1d9a19b 100644
--- a/packages/Catch2/src/catch2/catch_template_test_macros.hpp
+++ b/packages/Catch2/src/catch2/catch_template_test_macros.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_test_case_info.cpp b/packages/Catch2/src/catch2/catch_test_case_info.cpp
index c1a0a4310aa474e2f2f77c51c6420178fa571ed6..e9dad57787036172a30deb088c8c6a2bea1c6883 100644
--- a/packages/Catch2/src/catch2/catch_test_case_info.cpp
+++ b/packages/Catch2/src/catch2/catch_test_case_info.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -139,12 +139,20 @@ namespace Catch {
for (size_t idx = 0; idx < originalTags.size(); ++idx) {
auto c = originalTags[idx];
if (c == '[') {
- assert(!inTag);
+ CATCH_ENFORCE(
+ !inTag,
+ "Found '[' inside a tag while registering test case '"
+ << _nameAndTags.name << "' at " << _lineInfo );
+
inTag = true;
tagStart = idx;
}
if (c == ']') {
- assert(inTag);
+ CATCH_ENFORCE(
+ inTag,
+ "Found unmatched ']' while registering test case '"
+ << _nameAndTags.name << "' at " << _lineInfo );
+
inTag = false;
tagEnd = idx;
assert(tagStart < tagEnd);
@@ -153,7 +161,11 @@ namespace Catch {
// it over to backing storage and actually reference the
// backing storage in the saved tags
StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
- CATCH_ENFORCE(!tagStr.empty(), "Empty tags are not allowed");
+ CATCH_ENFORCE( !tagStr.empty(),
+ "Found an empty tag while registering test case '"
+ << _nameAndTags.name << "' at "
+ << _lineInfo );
+
enforceNotReservedTag(tagStr, lineInfo);
properties |= parseSpecialTag(tagStr);
// When copying a tag to the backing storage, we need to
@@ -167,8 +179,12 @@ namespace Catch {
// the tags.
internalAppendTag(tagStr);
}
- (void)inTag; // Silence "set-but-unused" warning in release mode.
}
+ CATCH_ENFORCE( !inTag,
+ "Found an unclosed tag while registering test case '"
+ << _nameAndTags.name << "' at " << _lineInfo );
+
+
// Add [.] if relevant
if (isHidden()) {
internalAppendTag("."_sr);
diff --git a/packages/Catch2/src/catch2/catch_test_case_info.hpp b/packages/Catch2/src/catch2/catch_test_case_info.hpp
index 6cfc2aaf99b8863d8e6e66e4f4f4210e78e9ef76..5ff3e3e7207e3002a69516fddb34f77f889afa99 100644
--- a/packages/Catch2/src/catch2/catch_test_case_info.hpp
+++ b/packages/Catch2/src/catch2/catch_test_case_info.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -15,6 +15,7 @@
#include <catch2/internal/catch_unique_ptr.hpp>
+#include <cstdint>
#include <string>
#include <vector>
diff --git a/packages/Catch2/src/catch2/catch_test_macros.hpp b/packages/Catch2/src/catch2/catch_test_macros.hpp
index e92a45f0fa9dade729354ffb6185ad54a957e1c1..1088afbedd8b2590ccc55469c50db2185ac42ebd 100644
--- a/packages/Catch2/src/catch2/catch_test_macros.hpp
+++ b/packages/Catch2/src/catch2/catch_test_macros.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -49,6 +49,7 @@
#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -102,6 +103,7 @@
#define CATCH_FAIL( ... ) (void)(0)
#define CATCH_FAIL_CHECK( ... ) (void)(0)
#define CATCH_SUCCEED( ... ) (void)(0)
+ #define CATCH_SKIP( ... ) (void)(0)
#define CATCH_STATIC_REQUIRE( ... ) (void)(0)
#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
@@ -146,6 +148,7 @@
#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
@@ -198,6 +201,7 @@
#define FAIL( ... ) (void)(0)
#define FAIL_CHECK( ... ) (void)(0)
#define SUCCEED( ... ) (void)(0)
+ #define SKIP( ... ) (void)(0)
#define STATIC_REQUIRE( ... ) (void)(0)
#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
diff --git a/packages/Catch2/src/catch2/catch_test_spec.cpp b/packages/Catch2/src/catch2/catch_test_spec.cpp
index a3235d432ff6635a2a3925ee691e06969bd9f8c9..f32f9864c2749c5bc3105384a9096404d4bb103d 100644
--- a/packages/Catch2/src/catch2/catch_test_spec.cpp
+++ b/packages/Catch2/src/catch2/catch_test_spec.cpp
@@ -1,17 +1,21 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/catch_test_spec.hpp>
+#include <catch2/interfaces/catch_interfaces_testcase.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
+#include <catch2/internal/catch_reusable_string_stream.hpp>
#include <catch2/internal/catch_string_manip.hpp>
#include <catch2/catch_test_case_info.hpp>
#include <algorithm>
#include <string>
#include <vector>
+#include <ostream>
namespace Catch {
@@ -35,6 +39,10 @@ namespace Catch {
return m_wildcardPattern.matches( testCase.name );
}
+ void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
+ out << '"' << name() << '"';
+ }
+
TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
: Pattern( filterString )
@@ -47,6 +55,10 @@ namespace Catch {
Tag( m_tag ) ) != end( testCase.tags );
}
+ void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
+ out << name();
+ }
+
bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
bool should_use = !testCase.isHidden();
for (auto const& pattern : m_required) {
@@ -63,18 +75,31 @@ namespace Catch {
return should_use;
}
- std::string TestSpec::Filter::name() const {
- std::string name;
- for (auto const& p : m_required) {
- name += p->name();
+ void TestSpec::Filter::serializeTo( std::ostream& out ) const {
+ bool first = true;
+ for ( auto const& pattern : m_required ) {
+ if ( !first ) {
+ out << ' ';
+ }
+ out << *pattern;
+ first = false;
}
- for (auto const& p : m_forbidden) {
- name += p->name();
+ for ( auto const& pattern : m_forbidden ) {
+ if ( !first ) {
+ out << ' ';
+ }
+ out << *pattern;
+ first = false;
}
- return name;
}
+ std::string TestSpec::extractFilterName( Filter const& filter ) {
+ Catch::ReusableStringStream sstr;
+ sstr << filter;
+ return sstr.str();
+ }
+
bool TestSpec::hasFilters() const {
return !m_filters.empty();
}
@@ -83,16 +108,18 @@ namespace Catch {
return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
}
- TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const
- {
- Matches matches( m_filters.size() );
- std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+ TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
+ Matches matches;
+ matches.reserve( m_filters.size() );
+ for ( auto const& filter : m_filters ) {
std::vector<TestCaseHandle const*> currentMatches;
- for( auto const& test : testCases )
- if( isThrowSafe( test, config ) && filter.matches( test.getTestCaseInfo() ) )
+ for ( auto const& test : testCases )
+ if ( isThrowSafe( test, config ) &&
+ filter.matches( test.getTestCaseInfo() ) )
currentMatches.emplace_back( &test );
- return FilterMatch{ filter.name(), currentMatches };
- } );
+ matches.push_back(
+ FilterMatch{ extractFilterName( filter ), currentMatches } );
+ }
return matches;
}
@@ -100,4 +127,15 @@ namespace Catch {
return m_invalidSpecs;
}
+ void TestSpec::serializeTo( std::ostream& out ) const {
+ bool first = true;
+ for ( auto const& filter : m_filters ) {
+ if ( !first ) {
+ out << ',';
+ }
+ out << filter;
+ first = false;
+ }
+ }
+
}
diff --git a/packages/Catch2/src/catch2/catch_test_spec.hpp b/packages/Catch2/src/catch2/catch_test_spec.hpp
index 499bfaa56c800b92cfab0b757142417aa7be051b..f12baa636edaa9ae598c4c9db1455f59d7015c6c 100644
--- a/packages/Catch2/src/catch2/catch_test_spec.hpp
+++ b/packages/Catch2/src/catch2/catch_test_spec.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -16,6 +16,7 @@
#include <catch2/internal/catch_unique_ptr.hpp>
#include <catch2/internal/catch_wildcard_pattern.hpp>
+#include <iosfwd>
#include <string>
#include <vector>
@@ -34,6 +35,14 @@ namespace Catch {
virtual bool matches( TestCaseInfo const& testCase ) const = 0;
std::string const& name() const;
private:
+ virtual void serializeTo( std::ostream& out ) const = 0;
+ // Writes string that would be reparsed into the pattern
+ friend std::ostream& operator<<(std::ostream& out,
+ Pattern const& pattern) {
+ pattern.serializeTo( out );
+ return out;
+ }
+
std::string const m_name;
};
@@ -42,6 +51,8 @@ namespace Catch {
explicit NamePattern( std::string const& name, std::string const& filterString );
bool matches( TestCaseInfo const& testCase ) const override;
private:
+ void serializeTo( std::ostream& out ) const override;
+
WildcardPattern m_wildcardPattern;
};
@@ -50,6 +61,8 @@ namespace Catch {
explicit TagPattern( std::string const& tag, std::string const& filterString );
bool matches( TestCaseInfo const& testCase ) const override;
private:
+ void serializeTo( std::ostream& out ) const override;
+
std::string m_tag;
};
@@ -57,10 +70,19 @@ namespace Catch {
std::vector<Detail::unique_ptr<Pattern>> m_required;
std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
+ //! Serializes this filter into a string that would be parsed into
+ //! an equivalent filter
+ void serializeTo( std::ostream& out ) const;
+ friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
+ f.serializeTo( out );
+ return out;
+ }
+
bool matches( TestCaseInfo const& testCase ) const;
- std::string name() const;
};
+ static std::string extractFilterName( Filter const& filter );
+
public:
struct FilterMatch {
std::string name;
@@ -77,7 +99,16 @@ namespace Catch {
private:
std::vector<Filter> m_filters;
std::vector<std::string> m_invalidSpecs;
+
friend class TestSpecParser;
+ //! Serializes this test spec into a string that would be parsed into
+ //! equivalent test spec
+ void serializeTo( std::ostream& out ) const;
+ friend std::ostream& operator<<(std::ostream& out,
+ TestSpec const& spec) {
+ spec.serializeTo( out );
+ return out;
+ }
};
}
diff --git a/packages/Catch2/src/catch2/catch_timer.cpp b/packages/Catch2/src/catch2/catch_timer.cpp
index d67d94ca6800a015e245a8aee78c275f6ed2e638..d75ea70c8b4892cca102c8a063edd3ee3e8f42d7 100644
--- a/packages/Catch2/src/catch2/catch_timer.cpp
+++ b/packages/Catch2/src/catch2/catch_timer.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_timer.hpp b/packages/Catch2/src/catch2/catch_timer.hpp
index 30e814150335c995238dbda9134736f70150e1b7..f42589ff1b06e8f7f209b63ebd2b598be3272fda 100644
--- a/packages/Catch2/src/catch2/catch_timer.hpp
+++ b/packages/Catch2/src/catch2/catch_timer.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_tostring.cpp b/packages/Catch2/src/catch2/catch_tostring.cpp
index 4c24234eef9f4222031193457a7722b51c75bc83..b97cf560dc0e7309f99e34090846293c27fc7ae1 100644
--- a/packages/Catch2/src/catch2/catch_tostring.cpp
+++ b/packages/Catch2/src/catch2/catch_tostring.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_tostring.hpp b/packages/Catch2/src/catch2/catch_tostring.hpp
index 964c8a665e8928d0f8737551d32510b21877f8d4..788d824c899d4f5a7d66081d08a302f8f3b02908 100644
--- a/packages/Catch2/src/catch2/catch_tostring.hpp
+++ b/packages/Catch2/src/catch2/catch_tostring.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,7 +13,6 @@
#include <cstddef>
#include <type_traits>
#include <string>
-#include <string.h>
#include <catch2/internal/catch_compiler_capabilities.hpp>
#include <catch2/internal/catch_config_wchar.hpp>
@@ -41,6 +40,13 @@ namespace Catch {
namespace Detail {
+ inline std::size_t catch_strnlen(const char *str, std::size_t n) {
+ auto ret = std::char_traits<char>::find(str, n, '\0');
+ if (ret != nullptr) {
+ return static_cast<std::size_t>(ret - str);
+ }
+ return n;
+ }
constexpr StringRef unprintableString = "{?}"_sr;
@@ -110,7 +116,6 @@ namespace Catch {
} // namespace Detail
- // If we decide for C++14, change these to enable_if_ts
template <typename T, typename = void>
struct StringMaker {
template <typename Fake = T>
@@ -208,28 +213,24 @@ namespace Catch {
template<size_t SZ>
struct StringMaker<char[SZ]> {
static std::string convert(char const* str) {
- // Note that `strnlen` is not actually part of standard C++,
- // but both POSIX and Windows cstdlib provide it.
return Detail::convertIntoString(
- StringRef( str, strnlen( str, SZ ) ) );
+ StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
}
};
template<size_t SZ>
struct StringMaker<signed char[SZ]> {
static std::string convert(signed char const* str) {
- // See the plain `char const*` overload
auto reinterpreted = reinterpret_cast<char const*>(str);
return Detail::convertIntoString(
- StringRef(reinterpreted, strnlen(reinterpreted, SZ)));
+ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
}
};
template<size_t SZ>
struct StringMaker<unsigned char[SZ]> {
static std::string convert(unsigned char const* str) {
- // See the plain `char const*` overload
auto reinterpreted = reinterpret_cast<char const*>(str);
return Detail::convertIntoString(
- StringRef(reinterpreted, strnlen(reinterpreted, SZ)));
+ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
}
};
@@ -296,13 +297,13 @@ namespace Catch {
template<>
struct StringMaker<float> {
static std::string convert(float value);
- static int precision;
+ CATCH_EXPORT static int precision;
};
template<>
struct StringMaker<double> {
static std::string convert(double value);
- static int precision;
+ CATCH_EXPORT static int precision;
};
template <typename T>
diff --git a/packages/Catch2/src/catch2/catch_totals.cpp b/packages/Catch2/src/catch2/catch_totals.cpp
index 14a23869dfd1eb1f670850901de5f20ec04b6e02..bd1954fb9e38e6b9f3fd52f882be0ac6520af7a1 100644
--- a/packages/Catch2/src/catch2/catch_totals.cpp
+++ b/packages/Catch2/src/catch2/catch_totals.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -14,6 +14,7 @@ namespace Catch {
diff.passed = passed - other.passed;
diff.failed = failed - other.failed;
diff.failedButOk = failedButOk - other.failedButOk;
+ diff.skipped = skipped - other.skipped;
return diff;
}
@@ -21,14 +22,15 @@ namespace Catch {
passed += other.passed;
failed += other.failed;
failedButOk += other.failedButOk;
+ skipped += other.skipped;
return *this;
}
std::uint64_t Counts::total() const {
- return passed + failed + failedButOk;
+ return passed + failed + failedButOk + skipped;
}
bool Counts::allPassed() const {
- return failed == 0 && failedButOk == 0;
+ return failed == 0 && failedButOk == 0 && skipped == 0;
}
bool Counts::allOk() const {
return failed == 0;
@@ -53,6 +55,8 @@ namespace Catch {
++diff.testCases.failed;
else if( diff.assertions.failedButOk > 0 )
++diff.testCases.failedButOk;
+ else if ( diff.assertions.skipped > 0 )
+ ++ diff.testCases.skipped;
else
++diff.testCases.passed;
return diff;
diff --git a/packages/Catch2/src/catch2/catch_totals.hpp b/packages/Catch2/src/catch2/catch_totals.hpp
index 6bc444fc2f547ee2aa8fd07a0335915e293df9cb..386392c91f0b4d3486f7dfc324cbecddd4733973 100644
--- a/packages/Catch2/src/catch2/catch_totals.hpp
+++ b/packages/Catch2/src/catch2/catch_totals.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -23,6 +23,7 @@ namespace Catch {
std::uint64_t passed = 0;
std::uint64_t failed = 0;
std::uint64_t failedButOk = 0;
+ std::uint64_t skipped = 0;
};
struct Totals {
diff --git a/packages/Catch2/src/catch2/catch_translate_exception.cpp b/packages/Catch2/src/catch2/catch_translate_exception.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4b289449c9a5afc4618b1b3e4828f04a19f48e9
--- /dev/null
+++ b/packages/Catch2/src/catch2/catch_translate_exception.cpp
@@ -0,0 +1,20 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_translate_exception.hpp>
+#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
+
+namespace Catch {
+ namespace Detail {
+ void registerTranslatorImpl(
+ Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+ getMutableRegistryHub().registerTranslator(
+ CATCH_MOVE( translator ) );
+ }
+ } // namespace Detail
+} // namespace Catch
diff --git a/packages/Catch2/src/catch2/catch_translate_exception.hpp b/packages/Catch2/src/catch2/catch_translate_exception.hpp
index 4a0be629da9ed63fc8be0124365512ca63ac225d..5a4dc5e376e79451817e03a6a85ddfef3fd66f71 100644
--- a/packages/Catch2/src/catch2/catch_translate_exception.hpp
+++ b/packages/Catch2/src/catch2/catch_translate_exception.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -15,6 +15,10 @@
#include <exception>
namespace Catch {
+ namespace Detail {
+ void registerTranslatorImpl(
+ Detail::unique_ptr<IExceptionTranslator>&& translator );
+ }
class ExceptionTranslatorRegistrar {
template<typename T>
@@ -48,9 +52,9 @@ namespace Catch {
public:
template<typename T>
ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
- getMutableRegistryHub().registerTranslator(
- Detail::make_unique<ExceptionTranslator<T>>(translateFunction)
- );
+ Detail::registerTranslatorImpl(
+ Detail::make_unique<ExceptionTranslator<T>>(
+ translateFunction ) );
}
};
diff --git a/packages/Catch2/src/catch2/catch_user_config.hpp.in b/packages/Catch2/src/catch2/catch_user_config.hpp.in
index 77c94291cd8d2117efadbee7c02d041d22754291..11ab5a6d1aae25ca516859f84c6b46242d28fb39 100644
--- a/packages/Catch2/src/catch2/catch_user_config.hpp.in
+++ b/packages/Catch2/src/catch2/catch_user_config.hpp.in
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -130,6 +130,16 @@
+#cmakedefine CATCH_CONFIG_GETENV
+#cmakedefine CATCH_CONFIG_NO_GETENV
+
+#if defined( CATCH_CONFIG_GETENV ) && \
+ defined( CATCH_CONFIG_NO_GETENV )
+# error Cannot force GETENV to both ON and OFF
+#endif
+
+
+
#cmakedefine CATCH_CONFIG_USE_ASYNC
#cmakedefine CATCH_CONFIG_NO_USE_ASYNC
@@ -159,9 +169,18 @@
#endif
+#cmakedefine CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+#cmakedefine CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+
+#if defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
+ defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
+# error Cannot force STATIC_ANALYSIS_SUPPORT to both ON and OFF
+#endif
+
+
// ------
// Simple toggle defines
-// their value is never used and they cannot be overriden
+// their value is never used and they cannot be overridden
// ------
@@ -181,6 +200,8 @@
#cmakedefine CATCH_CONFIG_PREFIX_ALL
#cmakedefine CATCH_CONFIG_WINDOWS_CRTDBG
+#cmakedefine CATCH_CONFIG_SHARED_LIBRARY
+
// ------
// "Variable" defines, these have actual values
diff --git a/packages/Catch2/src/catch2/catch_version.cpp b/packages/Catch2/src/catch2/catch_version.cpp
index a7075f3006e09e2946e75515f0c7a77d4e74fdc2..19cab91b3db63f719726c752c85eab12f1380e38 100644
--- a/packages/Catch2/src/catch2/catch_version.cpp
+++ b/packages/Catch2/src/catch2/catch_version.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -36,7 +36,7 @@ namespace Catch {
}
Version const& libraryVersion() {
- static Version version( 3, 1, 0, "", 0 );
+ static Version version( 3, 3, 2, "", 0 );
return version;
}
diff --git a/packages/Catch2/src/catch2/catch_version.hpp b/packages/Catch2/src/catch2/catch_version.hpp
index 1f64d163760e4c889d701ea04a197dd03fe2e7cd..af698fad5fe5b3be29f5834183da9fa033ebafb9 100644
--- a/packages/Catch2/src/catch2/catch_version.hpp
+++ b/packages/Catch2/src/catch2/catch_version.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/catch_version_macros.hpp b/packages/Catch2/src/catch2/catch_version_macros.hpp
index c7212e3a6ad22e86bbaef94ffda018ba1f6b0f19..9ece85051120b099f0f70b1e217243f3cb15c320 100644
--- a/packages/Catch2/src/catch2/catch_version_macros.hpp
+++ b/packages/Catch2/src/catch2/catch_version_macros.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -9,7 +9,7 @@
#define CATCH_VERSION_MACROS_HPP_INCLUDED
#define CATCH_VERSION_MAJOR 3
-#define CATCH_VERSION_MINOR 1
-#define CATCH_VERSION_PATCH 0
+#define CATCH_VERSION_MINOR 3
+#define CATCH_VERSION_PATCH 2
#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/generators/catch_generator_exception.cpp b/packages/Catch2/src/catch2/generators/catch_generator_exception.cpp
index 70a991e3c8c43217b72fb9ea38f627441293dee3..64324039267435cea79ace2dee7c439520121590 100644
--- a/packages/Catch2/src/catch2/generators/catch_generator_exception.cpp
+++ b/packages/Catch2/src/catch2/generators/catch_generator_exception.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/generators/catch_generator_exception.hpp b/packages/Catch2/src/catch2/generators/catch_generator_exception.hpp
index a049452cd2c75ac1759c9faa7340752e48641294..f353042eb562b918a3eb73e7c7cd5ec4be0846c5 100644
--- a/packages/Catch2/src/catch2/generators/catch_generator_exception.hpp
+++ b/packages/Catch2/src/catch2/generators/catch_generator_exception.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/generators/catch_generators.cpp b/packages/Catch2/src/catch2/generators/catch_generators.cpp
index 3e09bfd9ebe7844c9999e24743e650594d0195bd..3514e9f63218189823b67de89873a2acc917008f 100644
--- a/packages/Catch2/src/catch2/generators/catch_generators.cpp
+++ b/packages/Catch2/src/catch2/generators/catch_generators.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -27,9 +27,16 @@ namespace Detail {
GeneratorUntypedBase::~GeneratorUntypedBase() = default;
- auto acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+ IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
}
+ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ GeneratorBasePtr&& generator ) {
+ return getResultCapture().createGeneratorTracker(
+ generatorName, lineInfo, CATCH_MOVE( generator ) );
+ }
+
} // namespace Generators
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/generators/catch_generators.hpp b/packages/Catch2/src/catch2/generators/catch_generators.hpp
index 1de04e3bddad492c78d8c54c22378b00168f4b92..117f190193ce241e11cf17a3c1ebfd78b3ededb9 100644
--- a/packages/Catch2/src/catch2/generators/catch_generators.hpp
+++ b/packages/Catch2/src/catch2/generators/catch_generators.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -14,7 +14,6 @@
#include <catch2/internal/catch_stringref.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
#include <catch2/internal/catch_unique_name.hpp>
-#include <catch2/internal/catch_preprocessor.hpp>
#include <vector>
#include <tuple>
@@ -204,37 +203,47 @@ namespace Detail {
return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
}
- auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+ IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo );
+ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ GeneratorBasePtr&& generator );
template<typename L>
- // Note: The type after -> is weird, because VS2015 cannot parse
- // the expression used in the typedef inside, when it is in
- // return type. Yeah.
- auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+ auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
using UnderlyingType = typename decltype(generatorExpression())::type;
- IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
- if (!tracker.hasGenerator()) {
- tracker.setGenerator(Catch::Detail::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+ IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
+ // Creation of tracker is delayed after generator creation, so
+ // that constructing generator can fail without breaking everything.
+ if (!tracker) {
+ tracker = createGeneratorTracker(
+ generatorName,
+ lineInfo,
+ Catch::Detail::make_unique<Generators<UnderlyingType>>(
+ generatorExpression() ) );
}
- auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+ auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
return generator.get();
}
} // namespace Generators
} // namespace Catch
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)
+
#define GENERATE( ... ) \
- Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
CATCH_INTERNAL_LINEINFO, \
[ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_COPY( ... ) \
- Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
CATCH_INTERNAL_LINEINFO, \
[=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_REF( ... ) \
- Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
CATCH_INTERNAL_LINEINFO, \
[&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
diff --git a/packages/Catch2/src/catch2/generators/catch_generators_adapters.hpp b/packages/Catch2/src/catch2/generators/catch_generators_adapters.hpp
index c55a3962538b0335bdd6ce1df8570f8f312e499c..d5fc1e12ad3eeb56d07bd0157760d00abe02262f 100644
--- a/packages/Catch2/src/catch2/generators/catch_generators_adapters.hpp
+++ b/packages/Catch2/src/catch2/generators/catch_generators_adapters.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/generators/catch_generators_all.hpp b/packages/Catch2/src/catch2/generators/catch_generators_all.hpp
index 845e6516d72859016184be5e71bcae302f7a0d8f..c12d314e83840d386faa3bb23718dff3e9c9fed0 100644
--- a/packages/Catch2/src/catch2/generators/catch_generators_all.hpp
+++ b/packages/Catch2/src/catch2/generators/catch_generators_all.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/generators/catch_generators_random.cpp b/packages/Catch2/src/catch2/generators/catch_generators_random.cpp
index 57ad174553692589a416d2603422269cf8b34b85..2e3390fdfca69fa312abef527ab2b9662a25f5b1 100644
--- a/packages/Catch2/src/catch2/generators/catch_generators_random.cpp
+++ b/packages/Catch2/src/catch2/generators/catch_generators_random.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/generators/catch_generators_random.hpp b/packages/Catch2/src/catch2/generators/catch_generators_random.hpp
index e9ff92084d2df15a9fa5f9b665233efa12b73c99..bcd4888dc3d3e6bdb94113309429290f897e8626 100644
--- a/packages/Catch2/src/catch2/generators/catch_generators_random.hpp
+++ b/packages/Catch2/src/catch2/generators/catch_generators_random.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/generators/catch_generators_range.hpp b/packages/Catch2/src/catch2/generators/catch_generators_range.hpp
index 054af15d546891e03bde83eb0d7b143e5ebab3af..495acb9509b1e616014184da18f447f6073fcfc2 100644
--- a/packages/Catch2/src/catch2/generators/catch_generators_range.hpp
+++ b/packages/Catch2/src/catch2/generators/catch_generators_range.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_all.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_all.hpp
index 2960bf6763b11f06567a2ff35002fd4233ba0c05..a99fdcdc91493cef73f0230ab7942e85db1b79f5 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_all.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_all.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -30,8 +30,8 @@
#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
+#include <catch2/interfaces/catch_interfaces_test_invoker.hpp>
#include <catch2/interfaces/catch_interfaces_testcase.hpp>
#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.cpp
index fb98a75d8baec0ed7a3ce8e806310f3387028a81..9b40ee5d696a6e2d6a28612aa682b06fa8bf2ec9 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.hpp
index 6981e724bcdf978387acf83f5114a648ecfbf0cb..a1876a4cad8abf6ef5073829ab3de2fa32891f84 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_capture.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,6 +13,8 @@
#include <catch2/internal/catch_stringref.hpp>
#include <catch2/internal/catch_result_type.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
+#include <catch2/benchmark/detail/catch_benchmark_stats_fwd.hpp>
namespace Catch {
@@ -30,19 +32,31 @@ namespace Catch {
class IGeneratorTracker;
struct BenchmarkInfo;
- template <typename Duration = std::chrono::duration<double, std::nano>>
- struct BenchmarkStats;
+
+ namespace Generators {
+ class GeneratorUntypedBase;
+ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+ }
+
class IResultCapture {
public:
virtual ~IResultCapture();
- virtual bool sectionStarted( SectionInfo const& sectionInfo,
- Counts& assertions ) = 0;
- virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
- virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-
- virtual auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+ virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
+ virtual bool sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) = 0;
+ virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
+ virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
+
+ virtual IGeneratorTracker*
+ acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) = 0;
+ virtual IGeneratorTracker*
+ createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) = 0;
virtual void benchmarkPreparing( StringRef name ) = 0;
virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
@@ -52,7 +66,7 @@ namespace Catch {
virtual void pushScopedMessage( MessageInfo const& message ) = 0;
virtual void popScopedMessage( MessageInfo const& message ) = 0;
- virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+ virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
virtual void handleFatalErrorCondition( StringRef message ) = 0;
@@ -70,7 +84,7 @@ namespace Catch {
AssertionReaction& reaction ) = 0;
virtual void handleUnexpectedInflightException
( AssertionInfo const& info,
- std::string const& message,
+ std::string&& message,
AssertionReaction& reaction ) = 0;
virtual void handleIncomplete
( AssertionInfo const& info ) = 0;
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.cpp
index 13d761dfbf54624eade17ca1d00735d368861d66..655bc1b425e355451892d2da9824667969732fe8 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.hpp
index 5e358650a4dcdaeefb30f2aa52e46b25b47520b3..eb054805e0c8130cca7277c236e9fc157687ed79 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_config.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_enum_values_registry.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_enum_values_registry.hpp
index cf25d896eadba2be187f4f87d2f5d57c70184f24..38b052d906da35bc964d0d8fc3e05e1ce38027bd 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_enum_values_registry.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_enum_values_registry.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.cpp
index f0de7450e1eed8fa9d96d8e83f6dbefb4dbe2828..44c272d2c6e6c8c0ca94217d24afc37442726765 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.hpp
index b72b49a105f8a1df80d1d6269a4caf8d7f21fbae..fcc2a8f9ce3671e054f542b92f0a46d6dd3110b2 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_exception.hpp
@@ -1,14 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
#include <catch2/internal/catch_unique_ptr.hpp>
#include <string>
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.cpp
index e8c67b543a9ede7f9c5fac02695cf6c1d0c57129..e9fa5ddac2562f96d0867b8641781190320d245e 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.hpp
index 83e3d783a923fc3a5550fcb7e582de0be70e5ac5..d70cb593beb243cf7f627cc0d2162a19e0f7306d 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_generatortracker.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.cpp
index 557f7303731df86114939d457610d5068ff074bf..cd688a444847e320a49c0abaa36f07e43cb4a6b9 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.hpp
index 22e62b7967a4d1da04f33af7ca266cccc58eec9f..113f223e80422b711a5f10212824dea708b76326 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_registry_hub.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -19,7 +19,7 @@ namespace Catch {
class ITestCaseRegistry;
class IExceptionTranslatorRegistry;
class IExceptionTranslator;
- class IReporterRegistry;
+ class ReporterRegistry;
class IReporterFactory;
class ITagAliasRegistry;
class ITestInvoker;
@@ -35,7 +35,7 @@ namespace Catch {
public:
virtual ~IRegistryHub(); // = default
- virtual IReporterRegistry const& getReporterRegistry() const = 0;
+ virtual ReporterRegistry const& getReporterRegistry() const = 0;
virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.cpp
index b1ad584c148023995b7c8a5c50cbe9f15c8f8715..3274bcf50ebd03afd651b2778f90b2a296fe3f91 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -54,24 +54,21 @@ namespace Catch {
infoMessages( _infoMessages ),
totals( _totals )
{
- assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
-
if( assertionResult.hasMessage() ) {
// Copy message into messages list.
// !TBD This should have been done earlier, somewhere
MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
- builder << assertionResult.getMessage();
- builder.m_info.message = builder.m_stream.str();
+ builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
- infoMessages.push_back( builder.m_info );
+ infoMessages.push_back( CATCH_MOVE(builder.m_info) );
}
}
- SectionStats::SectionStats( SectionInfo const& _sectionInfo,
+ SectionStats::SectionStats( SectionInfo&& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
- : sectionInfo( _sectionInfo ),
+ : sectionInfo( CATCH_MOVE(_sectionInfo) ),
assertions( _assertions ),
durationInSeconds( _durationInSeconds ),
missingAssertions( _missingAssertions )
@@ -80,13 +77,13 @@ namespace Catch {
TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
- std::string const& _stdOut,
- std::string const& _stdErr,
+ std::string&& _stdOut,
+ std::string&& _stdErr,
bool _aborting )
: testInfo( &_testInfo ),
totals( _totals ),
- stdOut( _stdOut ),
- stdErr( _stdErr ),
+ stdOut( CATCH_MOVE(_stdOut) ),
+ stdErr( CATCH_MOVE(_stdErr) ),
aborting( _aborting )
{}
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.hpp
index 421924385046ff1151c950cfd4f5411ca9884998..b40fce3128960bdfaed980d31d7cf1dedeff81d6 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,11 +13,10 @@
#include <catch2/catch_assertion_result.hpp>
#include <catch2/internal/catch_message_info.hpp>
#include <catch2/internal/catch_stringref.hpp>
+#include <catch2/internal/catch_test_run_info.hpp>
#include <catch2/internal/catch_unique_ptr.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
-#include <catch2/benchmark/catch_estimate.hpp>
-#include <catch2/benchmark/catch_outlier_classification.hpp>
-
+#include <catch2/benchmark/detail/catch_benchmark_stats.hpp>
#include <map>
#include <string>
@@ -57,11 +56,6 @@ namespace Catch {
std::map<std::string, std::string> m_customOptions;
};
- struct TestRunInfo {
- constexpr TestRunInfo(StringRef _name) : name(_name) {}
- StringRef name;
- };
-
struct AssertionStats {
AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
@@ -78,7 +72,7 @@ namespace Catch {
};
struct SectionStats {
- SectionStats( SectionInfo const& _sectionInfo,
+ SectionStats( SectionInfo&& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions );
@@ -92,8 +86,8 @@ namespace Catch {
struct TestCaseStats {
TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
- std::string const& _stdOut,
- std::string const& _stdErr,
+ std::string&& _stdOut,
+ std::string&& _stdErr,
bool _aborting );
TestCaseInfo const * testInfo;
@@ -113,45 +107,6 @@ namespace Catch {
bool aborting;
};
-
- struct BenchmarkInfo {
- std::string name;
- double estimatedDuration;
- int iterations;
- unsigned int samples;
- unsigned int resamples;
- double clockResolution;
- double clockCost;
- };
-
- template <class Duration>
- struct BenchmarkStats {
- BenchmarkInfo info;
-
- std::vector<Duration> samples;
- Benchmark::Estimate<Duration> mean;
- Benchmark::Estimate<Duration> standardDeviation;
- Benchmark::OutlierClassification outliers;
- double outlierVariance;
-
- template <typename Duration2>
- operator BenchmarkStats<Duration2>() const {
- std::vector<Duration2> samples2;
- samples2.reserve(samples.size());
- for (auto const& sample : samples) {
- samples2.push_back(Duration2(sample));
- }
- return {
- info,
- CATCH_MOVE(samples2),
- mean,
- standardDeviation,
- outliers,
- outlierVariance,
- };
- }
- };
-
//! By setting up its preferences, a reporter can modify Catch2's behaviour
//! in some regards, e.g. it can request Catch2 to capture writes to
//! stdout/stderr during test execution, and pass them to the reporter.
@@ -242,10 +197,15 @@ namespace Catch {
*/
virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
- //! Called with test cases that are skipped due to the test run aborting
+ /**
+ * Called with test cases that are skipped due to the test run aborting.
+ * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
+ *
+ * Deprecated - will be removed in the next major release.
+ */
virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
- //! Called if a fatal error (signal/structured exception) occured
+ //! Called if a fatal error (signal/structured exception) occurred
virtual void fatalErrorEncountered( StringRef error ) = 0;
//! Writes out information about provided reporters using reporter-specific format
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.cpp
index 8732ed89a1efdc4c2e8595e446f8884311860d78..4fe992fa86bc5dbb142346866e2d9f0b84c93213 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.hpp
index 323edde26cdc79e3a039520934eab396504ed396..83ddd7bc387b141b716b1fe5fef252cc640348f5 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_factory.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_registry.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_registry.cpp
deleted file mode 100644
index bd38ac2886aa9317e157c4d1512c012af83c8fe7..0000000000000000000000000000000000000000
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_registry.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-
-// Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
-
-namespace Catch {
- IReporterRegistry::~IReporterRegistry() = default;
-}
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_registry.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_registry.hpp
deleted file mode 100644
index d2f2a1596bec8f68874184c0663933887458893c..0000000000000000000000000000000000000000
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_reporter_registry.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-
-// Copyright Catch2 Authors
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// https://www.boost.org/LICENSE_1_0.txt)
-
-// SPDX-License-Identifier: BSL-1.0
-#ifndef CATCH_INTERFACES_REPORTER_REGISTRY_HPP_INCLUDED
-#define CATCH_INTERFACES_REPORTER_REGISTRY_HPP_INCLUDED
-
-#include <catch2/internal/catch_case_insensitive_comparisons.hpp>
-#include <catch2/internal/catch_unique_ptr.hpp>
-
-#include <string>
-#include <vector>
-#include <map>
-
-namespace Catch {
-
- class IConfig;
-
- class IEventListener;
- using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
- class IReporterFactory;
- using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
- struct ReporterConfig;
- class EventListenerFactory;
-
- class IReporterRegistry {
- public:
- using FactoryMap = std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>;
- using Listeners = std::vector<Detail::unique_ptr<EventListenerFactory>>;
-
- virtual ~IReporterRegistry(); // = default
- virtual IEventListenerPtr create( std::string const& name, ReporterConfig&& config ) const = 0;
- virtual FactoryMap const& getFactories() const = 0;
- virtual Listeners const& getListeners() const = 0;
- };
-
-} // end namespace Catch
-
-#endif // CATCH_INTERFACES_REPORTER_REGISTRY_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_tag_alias_registry.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_tag_alias_registry.hpp
index 141560a1fd1c6026ae4fe1e5f078812682d6892d..5da0f8d1e0b6f2728b899b2b8391b9fd2b84a814 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_tag_alias_registry.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_tag_alias_registry.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_test_invoker.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_test_invoker.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3caeff9a32ff34bac69aa7e3012e245d87ccaf80
--- /dev/null
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_test_invoker.hpp
@@ -0,0 +1,21 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+
+namespace Catch {
+
+ class ITestInvoker {
+ public:
+ virtual void invoke() const = 0;
+ virtual ~ITestInvoker(); // = default
+ };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.cpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.cpp
index ec32d667bf082e9e425604a9ab4946f2ce37a19e..a543116c3f2db804cf3f8626e35a9faa75c8cf97 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.cpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -9,6 +9,5 @@
#include <catch2/interfaces/catch_interfaces_testcase.hpp>
namespace Catch {
- ITestInvoker::~ITestInvoker() = default;
ITestCaseRegistry::~ITestCaseRegistry() = default;
}
diff --git a/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.hpp b/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.hpp
index 9701d34218abbc2269f9fbabe591fc4d05090719..daee848295e1b92aa9f2881b99db05de66e5f9b4 100644
--- a/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.hpp
+++ b/packages/Catch2/src/catch2/interfaces/catch_interfaces_testcase.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -12,15 +12,7 @@
namespace Catch {
- class TestSpec;
struct TestCaseInfo;
-
- class ITestInvoker {
- public:
- virtual void invoke () const = 0;
- virtual ~ITestInvoker(); // = default
- };
-
class TestCaseHandle;
class IConfig;
@@ -33,11 +25,6 @@ namespace Catch {
virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
};
- bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
- bool matchTest( TestCaseHandle const& testCase, TestSpec const& testSpec, IConfig const& config );
- std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
- std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
-
}
#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_assertion_handler.cpp b/packages/Catch2/src/catch2/internal/catch_assertion_handler.cpp
index 828aa7cdff567238974b9d20e132377ea2bf0360..e5232f70c9a66c8e6f9b9a9e23633aa7433b3101 100644
--- a/packages/Catch2/src/catch2/internal/catch_assertion_handler.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_assertion_handler.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -12,7 +12,6 @@
#include <catch2/internal/catch_debugger.hpp>
#include <catch2/internal/catch_test_failure_exception.hpp>
#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
-#include <catch2/internal/catch_run_context.hpp>
#include <catch2/matchers/catch_matchers_string.hpp>
namespace Catch {
@@ -24,7 +23,9 @@ namespace Catch {
ResultDisposition::Flags resultDisposition )
: m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
m_resultCapture( getResultCapture() )
- {}
+ {
+ m_resultCapture.notifyAssertionStarted( m_assertionInfo );
+ }
void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
@@ -38,7 +39,7 @@ namespace Catch {
}
void AssertionHandler::complete() {
- setCompleted();
+ m_completed = true;
if( m_reaction.shouldDebugBreak ) {
// If you find your debugger stopping you here then go one level up on the
@@ -48,15 +49,11 @@ namespace Catch {
CATCH_BREAK_INTO_DEBUGGER();
}
if (m_reaction.shouldThrow) {
-#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
- throw Catch::TestFailureException();
-#else
- CATCH_ERROR( "Test failure requires aborting test!" );
-#endif
+ throw_test_failure_exception();
+ }
+ if ( m_reaction.shouldSkip ) {
+ throw_test_skip_exception();
}
- }
- void AssertionHandler::setCompleted() {
- m_completed = true;
}
void AssertionHandler::handleUnexpectedInflightException() {
@@ -80,8 +77,8 @@ namespace Catch {
// This is the overload that takes a string and infers the Equals matcher from it
// The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
- void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString ) {
- handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
+ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
+ handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
}
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_assertion_handler.hpp b/packages/Catch2/src/catch2/internal/catch_assertion_handler.hpp
index 5faa5e4ba6cfa680c8759e1e1ddcb9183f598106..01dd7801d19513cb874dd42c57b6dce32dcd1252 100644
--- a/packages/Catch2/src/catch2/internal/catch_assertion_handler.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_assertion_handler.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,17 +11,15 @@
#include <catch2/catch_assertion_info.hpp>
#include <catch2/internal/catch_decomposer.hpp>
#include <catch2/interfaces/catch_interfaces_capture.hpp>
-#include <catch2/internal/catch_lazy_expr.hpp>
#include <string>
namespace Catch {
- class IResultCapture;
-
struct AssertionReaction {
bool shouldDebugBreak = false;
bool shouldThrow = false;
+ bool shouldSkip = false;
};
class AssertionHandler {
@@ -58,13 +56,12 @@ namespace Catch {
void handleUnexpectedInflightException();
void complete();
- void setCompleted();
// query
auto allowThrows() const -> bool;
};
- void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString );
+ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.cpp b/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.cpp
index 904c2289b8b891e6bfc5d902845730279a5fca6d..b3e7b53ab030ab7f0ccb5867ecdd779294360a5f 100644
--- a/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.hpp b/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.hpp
index a97b7b4b9a629c8e999364df20837e296eb24283..33b778269e9b1b28289ddcccfeaaf54436fc2871 100644
--- a/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_case_insensitive_comparisons.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_case_sensitive.hpp b/packages/Catch2/src/catch2/internal/catch_case_sensitive.hpp
index f941d1f2f153cd74d1719c7a29f83203537f66d7..cc89110494b261fe8702004f6257ee6f2c119412 100644
--- a/packages/Catch2/src/catch2/internal/catch_case_sensitive.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_case_sensitive.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_clara.cpp b/packages/Catch2/src/catch2/internal/catch_clara.cpp
index b34ce917679300e9173d91aa2b3798bd2a7586ef..c9bc76959d0b1fb87186020093251055d95fe65d 100644
--- a/packages/Catch2/src/catch2/internal/catch_clara.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_clara.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_clara.hpp b/packages/Catch2/src/catch2/internal/catch_clara.hpp
index 512b0526c09752c047f2f2a463c4a93ce02de3bc..9117b65e84d51ff0c82d05904107a45afa61fcc9 100644
--- a/packages/Catch2/src/catch2/internal/catch_clara.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_clara.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_commandline.cpp b/packages/Catch2/src/catch2/internal/catch_commandline.cpp
index fda4b2bd55bbfc221f505993ad4e7238089ec713..4ac1847b20165d6ec0facba40c8bdbe350f7f8df 100644
--- a/packages/Catch2/src/catch2/internal/catch_commandline.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_commandline.cpp
@@ -1,18 +1,18 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/internal/catch_commandline.hpp>
-#include <catch2/internal/catch_compiler_capabilities.hpp>
#include <catch2/catch_config.hpp>
#include <catch2/internal/catch_string_manip.hpp>
#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
#include <catch2/internal/catch_console_colour.hpp>
+#include <catch2/internal/catch_parse_numbers.hpp>
#include <catch2/internal/catch_reporter_spec_parser.hpp>
#include <fstream>
@@ -77,23 +77,14 @@ namespace Catch {
return ParserResult::ok(ParseResultType::Matched);
}
- CATCH_TRY {
- std::size_t parsedTo = 0;
- unsigned long parsedSeed = std::stoul(seed, &parsedTo, 0);
- if (parsedTo != seed.size()) {
- return ParserResult::runtimeError("Could not parse '" + seed + "' as seed");
- }
-
- // TODO: Ideally we could parse unsigned int directly,
- // but the stdlib doesn't provide helper for that
- // type. After this is refactored to use fixed size
- // type, we should check the parsed value is in range
- // of the underlying type.
- config.rngSeed = static_cast<unsigned int>(parsedSeed);
- return ParserResult::ok(ParseResultType::Matched);
- } CATCH_CATCH_ANON(std::exception const&) {
- return ParserResult::runtimeError("Could not parse '" + seed + "' as seed");
+ // TODO: ideally we should be parsing uint32_t directly
+ // fix this later when we add new parse overload
+ auto parsedSeed = parseUInt( seed, 0 );
+ if ( !parsedSeed ) {
+ return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
}
+ config.rngSeed = *parsedSeed;
+ return ParserResult::ok( ParseResultType::Matched );
};
auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
@@ -153,7 +144,7 @@ namespace Catch {
auto const& reporterSpec = *parsed;
- IReporterRegistry::FactoryMap const& factories =
+ auto const& factories =
getRegistryHub().getReporterRegistry().getFactories();
auto result = factories.find( reporterSpec.name() );
@@ -185,42 +176,29 @@ namespace Catch {
return ParserResult::ok( ParseResultType::Matched );
};
auto const setShardCount = [&]( std::string const& shardCount ) {
- CATCH_TRY{
- std::size_t parsedTo = 0;
- int64_t parsedCount = std::stoll(shardCount, &parsedTo, 0);
- if (parsedTo != shardCount.size()) {
- return ParserResult::runtimeError("Could not parse '" + shardCount + "' as shard count");
- }
- if (parsedCount <= 0) {
- return ParserResult::runtimeError("Shard count must be a positive number");
- }
-
- config.shardCount = static_cast<unsigned int>(parsedCount);
- return ParserResult::ok(ParseResultType::Matched);
- } CATCH_CATCH_ANON(std::exception const&) {
- return ParserResult::runtimeError("Could not parse '" + shardCount + "' as shard count");
+ auto parsedCount = parseUInt( shardCount );
+ if ( !parsedCount ) {
+ return ParserResult::runtimeError(
+ "Could not parse '" + shardCount + "' as shard count" );
}
+ if ( *parsedCount == 0 ) {
+ return ParserResult::runtimeError(
+ "Shard count must be positive" );
+ }
+ config.shardCount = *parsedCount;
+ return ParserResult::ok( ParseResultType::Matched );
};
auto const setShardIndex = [&](std::string const& shardIndex) {
- CATCH_TRY{
- std::size_t parsedTo = 0;
- int64_t parsedIndex = std::stoll(shardIndex, &parsedTo, 0);
- if (parsedTo != shardIndex.size()) {
- return ParserResult::runtimeError("Could not parse '" + shardIndex + "' as shard index");
- }
- if (parsedIndex < 0) {
- return ParserResult::runtimeError("Shard index must be a non-negative number");
- }
-
- config.shardIndex = static_cast<unsigned int>(parsedIndex);
- return ParserResult::ok(ParseResultType::Matched);
- } CATCH_CATCH_ANON(std::exception const&) {
- return ParserResult::runtimeError("Could not parse '" + shardIndex + "' as shard index");
+ auto parsedIndex = parseUInt( shardIndex );
+ if ( !parsedIndex ) {
+ return ParserResult::runtimeError(
+ "Could not parse '" + shardIndex + "' as shard index" );
}
+ config.shardIndex = *parsedIndex;
+ return ParserResult::ok( ParseResultType::Matched );
};
-
auto cli
= ExeName( config.processName )
| Help( config.showHelp )
diff --git a/packages/Catch2/src/catch2/internal/catch_commandline.hpp b/packages/Catch2/src/catch2/internal/catch_commandline.hpp
index 1e03085644bae7ac3922b0febb1e39166b8efb6e..8cc2254764f32404b740ac24b32c358e404d64ce 100644
--- a/packages/Catch2/src/catch2/internal/catch_commandline.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_commandline.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_compare_traits.hpp b/packages/Catch2/src/catch2/internal/catch_compare_traits.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..6304b1ffeee4e909e5abb69ea2cd3412d44ebbfc
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_compare_traits.hpp
@@ -0,0 +1,75 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
+#define CATCH_COMPARE_TRAITS_HPP_INCLUDED
+
+#include <catch2/internal/catch_void_type.hpp>
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Detail {
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+# pragma GCC diagnostic push
+ // GCC likes to complain about comparing bool with 0, in the decltype()
+ // that defines the comparable traits below.
+# pragma GCC diagnostic ignored "-Wbool-compare"
+ // "ordered comparison of pointer with integer zero" same as above,
+ // but it does not have a separate warning flag to suppress
+# pragma GCC diagnostic ignored "-Wextra"
+ // Did you know that comparing floats with `0` directly
+ // is super-duper dangerous in unevaluated context?
+# pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+#if defined( __clang__ )
+# pragma clang diagnostic push
+ // Did you know that comparing floats with `0` directly
+ // is super-duper dangerous in unevaluated context?
+# pragma clang diagnostic ignored "-Wfloat-equal"
+#endif
+
+#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op ) \
+ template <typename, typename, typename = void> \
+ struct is_##id##_comparable : std::false_type {}; \
+ template <typename T, typename U> \
+ struct is_##id##_comparable< \
+ T, \
+ U, \
+ void_t<decltype( std::declval<T>() op std::declval<U>() )>> \
+ : std::true_type {}; \
+ template <typename, typename = void> \
+ struct is_##id##_0_comparable : std::false_type {}; \
+ template <typename T> \
+ struct is_##id##_0_comparable<T, \
+ void_t<decltype( std::declval<T>() op 0 )>> \
+ : std::true_type {};
+
+ // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
+ CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
+ CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
+ CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
+ CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
+ CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
+ CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )
+
+#undef CATCH_DEFINE_COMPARABLE_TRAIT
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+# pragma GCC diagnostic pop
+#endif
+#if defined( __clang__ )
+# pragma clang diagnostic pop
+#endif
+
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_compiler_capabilities.hpp b/packages/Catch2/src/catch2/internal/catch_compiler_capabilities.hpp
index 85477ec23d0b5d143a94eb965921a98c3bececda..fc5d4f31506bb67583aa9c9adcc396aa7d793b08 100644
--- a/packages/Catch2/src/catch2/internal/catch_compiler_capabilities.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_compiler_capabilities.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -41,7 +41,7 @@
// Only GCC compiler should be used in this block, so other compilers trying to
// mask themselves as GCC should be ignored.
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" )
@@ -50,17 +50,37 @@
# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
_Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
+
# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
_Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
+# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+ _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
+
# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
#endif
+#if defined(__NVCOMPILER)
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "diag pop" )
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
+#endif
+
#if defined(__CUDACC__) && !defined(__clang__)
+# ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+// New pragmas introduced in CUDA 11.5+
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic pop" )
# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
+# else
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
+# endif
#endif
// clang-cl defines _MSC_VER as well as __clang__, which could cause the
@@ -111,23 +131,35 @@
# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
_Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
-#endif // __clang__
+# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
+# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
+
+#endif // __clang__
-////////////////////////////////////////////////////////////////////////////////
-// Assume that non-Windows platforms support posix signals by default
-#if !defined(CATCH_PLATFORM_WINDOWS)
- #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
-#endif
////////////////////////////////////////////////////////////////////////////////
// We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
- #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#if defined( CATCH_PLATFORM_WINDOWS ) || \
+ defined( CATCH_PLATFORM_PLAYSTATION ) || \
+ defined( __CYGWIN__ ) || \
+ defined( __QNX__ ) || \
+ defined( __EMSCRIPTEN__ ) || \
+ defined( __DJGPP__ ) || \
+ defined( __OS400__ )
+# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#else
+# define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
#endif
-#ifdef __OS400__
-# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+////////////////////////////////////////////////////////////////////////////////
+// Assume that some platforms do not support getenv.
+#if defined(CATCH_PLATFORM_WINDOWS_UWP) || defined(CATCH_PLATFORM_PLAYSTATION)
+# define CATCH_INTERNAL_CONFIG_NO_GETENV
+#else
+# define CATCH_INTERNAL_CONFIG_GETENV
#endif
////////////////////////////////////////////////////////////////////////////////
@@ -169,8 +201,14 @@
// Visual C++
#if defined(_MSC_VER)
-# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
-# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) )
+// We want to defer to nvcc-specific warning suppression if we are compiled
+// with nvcc masquerading for MSVC.
+# if !defined( __CUDACC__ )
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ __pragma( warning( push ) )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ __pragma( warning( pop ) )
+# endif
// Universal Windows platform does not support SEH
// Or console colours (or console at all...)
@@ -270,6 +308,10 @@
# define CATCH_CONFIG_POSIX_SIGNALS
#endif
+#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
+# define CATCH_CONFIG_GETENV
+#endif
+
#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
# define CATCH_CONFIG_CPP11_TO_STRING
#endif
@@ -332,12 +374,28 @@
#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
+#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
+#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
+# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
+# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
+#endif
+
// The goal of this macro is to avoid evaluation of the arguments, but
// still have the compiler warn on problems inside...
@@ -351,9 +409,6 @@
# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
-# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
-#endif
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
#define CATCH_TRY if ((true))
@@ -376,5 +431,15 @@
# define CATCH_CONFIG_COLOUR_WIN32
#endif
+#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
+ !defined( CATCH_CONFIG_STATIC )
+# ifdef Catch2_EXPORTS
+# define CATCH_EXPORT //__declspec( dllexport ) // not needed
+# else
+# define CATCH_EXPORT __declspec( dllimport )
+# endif
+#else
+# define CATCH_EXPORT
+#endif
#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_config_android_logwrite.hpp b/packages/Catch2/src/catch2/internal/catch_config_android_logwrite.hpp
index 670af2d55c444d16bb01828735f226097eb5703b..490ee372acde6337b9747837223058d119d5e30a 100644
--- a/packages/Catch2/src/catch2/internal/catch_config_android_logwrite.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_config_android_logwrite.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_config_counter.hpp b/packages/Catch2/src/catch2/internal/catch_config_counter.hpp
index febb3eeef4ff228361e4f1c0c418d5a0cb962794..a482ce34628fb99cb64ef4b35ff06a829b46ca2d 100644
--- a/packages/Catch2/src/catch2/internal/catch_config_counter.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_config_counter.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -18,6 +18,8 @@
#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
#define CATCH_CONFIG_COUNTER_HPP_INCLUDED
+#include <catch2/catch_user_config.hpp>
+
#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
#define CATCH_INTERNAL_CONFIG_COUNTER
#endif
diff --git a/packages/Catch2/src/catch2/internal/catch_config_static_analysis_support.hpp b/packages/Catch2/src/catch2/internal/catch_config_static_analysis_support.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..81bdf39f4d80760a1beb751a7a8bb1c7368e5c4b
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_config_static_analysis_support.hpp
@@ -0,0 +1,34 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+/** \file
+ * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option
+ *
+ * Some of Catch2's macros can be defined differently to work better with
+ * static analysis tools, like clang-tidy or coverity.
+ * Currently the main use case is to show that `SECTION`s are executed
+ * exclusively, and not all in one run of a `TEST_CASE`.
+ */
+
+#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+
+#include <catch2/catch_user_config.hpp>
+
+#if defined(__clang_analyzer__) || defined(__COVERITY__)
+ #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
+#endif
+
+#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
+ !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
+ !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
+# define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+#endif
+
+
+#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_config_uncaught_exceptions.hpp b/packages/Catch2/src/catch2/internal/catch_config_uncaught_exceptions.hpp
index c853e673c5d34f62d4f639126f99339f63202eda..20b1dfca45db66e377f860a6ecaaec4dc922f3a6 100644
--- a/packages/Catch2/src/catch2/internal/catch_config_uncaught_exceptions.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_config_uncaught_exceptions.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -17,6 +17,8 @@
#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+#include <catch2/catch_user_config.hpp>
+
#if defined(_MSC_VER)
# if _MSC_VER >= 1900 // Visual Studio 2015 or newer
# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
diff --git a/packages/Catch2/src/catch2/internal/catch_config_wchar.hpp b/packages/Catch2/src/catch2/internal/catch_config_wchar.hpp
index fb64daf280b4d09da1eba56850bd1a8f349ce425..90d85d0552f286f8bada1934e17154ccd8aec6fa 100644
--- a/packages/Catch2/src/catch2/internal/catch_config_wchar.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_config_wchar.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -17,6 +17,8 @@
#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
#define CATCH_CONFIG_WCHAR_HPP_INCLUDED
+#include <catch2/catch_user_config.hpp>
+
// We assume that WCHAR should be enabled by default, and only disabled
// for a shortlist (so far only DJGPP) of compilers.
diff --git a/packages/Catch2/src/catch2/internal/catch_console_colour.cpp b/packages/Catch2/src/catch2/internal/catch_console_colour.cpp
index c77e8295182e1da15f8f89e3457b4521a0e19276..e1238816afdb8a4be6ca4ae350581133ed00fe48 100644
--- a/packages/Catch2/src/catch2/internal/catch_console_colour.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_console_colour.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -85,7 +85,7 @@ namespace Catch {
namespace {
//! A do-nothing implementation of colour, used as fallback for unknown
//! platforms, and when the user asks to deactivate all colours.
- class NoColourImpl : public ColourImpl {
+ class NoColourImpl final : public ColourImpl {
public:
NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
@@ -103,7 +103,7 @@ namespace Catch {
namespace Catch {
namespace {
- class Win32ColourImpl : public ColourImpl {
+ class Win32ColourImpl final : public ColourImpl {
public:
Win32ColourImpl(IStream* stream):
ColourImpl(stream) {
@@ -169,7 +169,7 @@ namespace {
namespace Catch {
namespace {
- class ANSIColourImpl : public ColourImpl {
+ class ANSIColourImpl final : public ColourImpl {
public:
ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
diff --git a/packages/Catch2/src/catch2/internal/catch_console_colour.hpp b/packages/Catch2/src/catch2/internal/catch_console_colour.hpp
index aa3d83a28e8fe82ec16719b3a69f71357512104d..d914431574b8af571d25a5529d1bf6ad08039e3d 100644
--- a/packages/Catch2/src/catch2/internal/catch_console_colour.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_console_colour.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -47,6 +47,7 @@ namespace Catch {
Error = BrightRed,
Success = Green,
+ Skip = LightGrey,
OriginalExpression = Cyan,
ReconstructedExpression = BrightYellow,
diff --git a/packages/Catch2/src/catch2/internal/catch_console_width.hpp b/packages/Catch2/src/catch2/internal/catch_console_width.hpp
index 7156ec4eea844bf5a93d853daf1aa74bca470e1d..165536174afa9bca42e3680989ca2fb7b950422d 100644
--- a/packages/Catch2/src/catch2/internal/catch_console_width.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_console_width.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_container_nonmembers.hpp b/packages/Catch2/src/catch2/internal/catch_container_nonmembers.hpp
index d6f10eb5ed0a9e5d07050441f17403dbf9a60377..33b28a9eb83533be96338c437bfc27a13393c204 100644
--- a/packages/Catch2/src/catch2/internal/catch_container_nonmembers.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_container_nonmembers.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_context.cpp b/packages/Catch2/src/catch2/internal/catch_context.cpp
index 6811b092f172d4d83914bffade7829105a305994..3b1cc277475151c2fd8aa8b7480f9a74d50cce0d 100644
--- a/packages/Catch2/src/catch2/internal/catch_context.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_context.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,49 +11,27 @@
namespace Catch {
- class Context : public IMutableContext, private Detail::NonCopyable {
+ Context* Context::currentContext = nullptr;
- public: // IContext
- IResultCapture* getResultCapture() override {
- return m_resultCapture;
- }
-
- IConfig const* getConfig() const override {
- return m_config;
- }
-
- ~Context() override;
-
- public: // IMutableContext
- void setResultCapture( IResultCapture* resultCapture ) override {
- m_resultCapture = resultCapture;
- }
- void setConfig( IConfig const* config ) override {
- m_config = config;
- }
-
- friend IMutableContext& getCurrentMutableContext();
-
- private:
- IConfig const* m_config = nullptr;
- IResultCapture* m_resultCapture = nullptr;
- };
-
- IMutableContext *IMutableContext::currentContext = nullptr;
-
- void IMutableContext::createContext()
- {
+ void cleanUpContext() {
+ delete Context::currentContext;
+ Context::currentContext = nullptr;
+ }
+ void Context::createContext() {
currentContext = new Context();
}
- void cleanUpContext() {
- delete IMutableContext::currentContext;
- IMutableContext::currentContext = nullptr;
+ Context& getCurrentMutableContext() {
+ if ( !Context::currentContext ) { Context::createContext(); }
+ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+ return *Context::currentContext;
+ }
+
+ void Context::setResultCapture( IResultCapture* resultCapture ) {
+ m_resultCapture = resultCapture;
}
- IContext::~IContext() = default;
- IMutableContext::~IMutableContext() = default;
- Context::~Context() = default;
+ void Context::setConfig( IConfig const* config ) { m_config = config; }
SimplePcg32& sharedRng() {
static SimplePcg32 s_rng;
diff --git a/packages/Catch2/src/catch2/internal/catch_context.hpp b/packages/Catch2/src/catch2/internal/catch_context.hpp
index fe1297056054e6d846e6affb32c6389aeba64a9b..6ccb3b318945e3d65837f02295c93729a5eb453b 100644
--- a/packages/Catch2/src/catch2/internal/catch_context.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_context.hpp
@@ -1,50 +1,45 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_CONTEXT_HPP_INCLUDED
#define CATCH_CONTEXT_HPP_INCLUDED
+#include <catch2/internal/catch_compiler_capabilities.hpp>
+
namespace Catch {
class IResultCapture;
class IConfig;
- class IContext {
- public:
- virtual ~IContext(); // = default
+ class Context {
+ IConfig const* m_config = nullptr;
+ IResultCapture* m_resultCapture = nullptr;
- virtual IResultCapture* getResultCapture() = 0;
- virtual IConfig const* getConfig() const = 0;
- };
+ CATCH_EXPORT static Context* currentContext;
+ friend Context& getCurrentMutableContext();
+ friend Context const& getCurrentContext();
+ static void createContext();
+ friend void cleanUpContext();
- class IMutableContext : public IContext {
public:
- ~IMutableContext() override; // = default
- virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
- virtual void setConfig( IConfig const* config ) = 0;
-
- private:
- static IMutableContext *currentContext;
- friend IMutableContext& getCurrentMutableContext();
- friend void cleanUpContext();
- static void createContext();
+ IResultCapture* getResultCapture() const { return m_resultCapture; }
+ IConfig const* getConfig() const { return m_config; }
+ void setResultCapture( IResultCapture* resultCapture );
+ void setConfig( IConfig const* config );
};
- inline IMutableContext& getCurrentMutableContext()
- {
- if( !IMutableContext::currentContext )
- IMutableContext::createContext();
- // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
- return *IMutableContext::currentContext;
- }
+ Context& getCurrentMutableContext();
- inline IContext& getCurrentContext()
- {
- return getCurrentMutableContext();
+ inline Context const& getCurrentContext() {
+ // We duplicate the logic from `getCurrentMutableContext` here,
+ // to avoid paying the call overhead in debug mode.
+ if ( !Context::currentContext ) { Context::createContext(); }
+ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+ return *Context::currentContext;
}
void cleanUpContext();
diff --git a/packages/Catch2/src/catch2/internal/catch_debug_console.cpp b/packages/Catch2/src/catch2/internal/catch_debug_console.cpp
index 5564c6a8847cd46dd2b4ad493246175de0771d61..40dd0a60480c45aad14b475f30b1f4dde74085c0 100644
--- a/packages/Catch2/src/catch2/internal/catch_debug_console.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_debug_console.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_debug_console.hpp b/packages/Catch2/src/catch2/internal/catch_debug_console.hpp
index a4b80f09b9e5cb636619f02fea7350b1156c021d..8784f7850ebe4247393b5f239b6e250f53265f18 100644
--- a/packages/Catch2/src/catch2/internal/catch_debug_console.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_debug_console.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_debugger.cpp b/packages/Catch2/src/catch2/internal/catch_debugger.cpp
index 349cf4ab35412828cf821bbc4eec7e576ad1547c..bd3be17289deea8c8d3cceaf388ed55410243c37 100644
--- a/packages/Catch2/src/catch2/internal/catch_debugger.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_debugger.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_debugger.hpp b/packages/Catch2/src/catch2/internal/catch_debugger.hpp
index ede291d7fae9c433e7abc7933d84600e3cdbf90e..25c5a2601339b0768f3c10f62201795161ec349d 100644
--- a/packages/Catch2/src/catch2/internal/catch_debugger.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_debugger.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -19,7 +19,10 @@ namespace Catch {
#if defined(__i386__) || defined(__x86_64__)
#define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
#elif defined(__aarch64__)
- #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
+ #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
+ #elif defined(__POWERPC__)
+ #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+ : : : "memory","r0","r3","r4" ) /* NOLINT */
#endif
#elif defined(CATCH_PLATFORM_IPHONE)
diff --git a/packages/Catch2/src/catch2/internal/catch_decomposer.cpp b/packages/Catch2/src/catch2/internal/catch_decomposer.cpp
index a85695389593f908b15f0453fd25004b09dcee93..3f398fcc2bde3cc1e5565d33c8dfd5ab17176c17 100644
--- a/packages/Catch2/src/catch2/internal/catch_decomposer.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_decomposer.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_decomposer.hpp b/packages/Catch2/src/catch2/internal/catch_decomposer.hpp
index e7dd1e9a4292648672573c0fd47087b80fbda2d9..e0e46c1de80cf86840fa5b4db425673378dbc6d4 100644
--- a/packages/Catch2/src/catch2/internal/catch_decomposer.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_decomposer.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,8 +10,11 @@
#include <catch2/catch_tostring.hpp>
#include <catch2/internal/catch_stringref.hpp>
-#include <catch2/internal/catch_meta.hpp>
+#include <catch2/internal/catch_compare_traits.hpp>
+#include <catch2/internal/catch_test_failure_exception.hpp>
+#include <catch2/internal/catch_logical_traits.hpp>
+#include <type_traits>
#include <iosfwd>
#ifdef _MSC_VER
@@ -33,6 +36,9 @@
namespace Catch {
+ template <typename T>
+ struct always_false : std::false_type {};
+
class ITransientExpression {
bool m_isBinaryExpression;
bool m_result;
@@ -155,68 +161,134 @@ namespace Catch {
};
- // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
- template<typename LhsT, typename RhsT>
- auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
- template<typename T>
- auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
- template<typename T>
- auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
-
- template<typename LhsT, typename RhsT>
- auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
- template<typename T>
- auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
- template<typename T>
- auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
- template<typename T>
- auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
-
-
template<typename LhsT>
class ExprLhs {
LhsT m_lhs;
public:
explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
- template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
- friend auto operator == ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
- return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
- }
- template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
- friend auto operator == ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
- return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
- }
-
- template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
- friend auto operator != ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
- return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
- }
- template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
- friend auto operator != ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
- return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
- }
-
- #define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(op) \
- template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0> \
- friend auto operator op ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> { \
- return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
- } \
- template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0> \
- friend auto operator op ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> { \
- return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
- }
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op ) \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ Detail::negation<std::is_arithmetic< \
+ std::remove_reference_t<RhsT>>>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ std::is_arithmetic<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_eq_0_comparable<LhsT>, \
+ /* We allow long because we want `ptr op NULL` to be accepted */ \
+ Detail::disjunction<std::is_same<RhsT, int>, \
+ std::is_same<RhsT, long>>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+ return { \
+ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_eq_0_comparable<RhsT>, \
+ /* We allow long because we want `ptr op NULL` to be accepted */ \
+ Detail::disjunction<std::is_same<LhsT, int>, \
+ std::is_same<LhsT, long>>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
+
+ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )
+
+ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op ) \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ Detail::negation<std::is_arithmetic< \
+ std::remove_reference_t<RhsT>>>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ std::is_arithmetic<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_##id##_0_comparable<LhsT>, \
+ std::is_same<RhsT, int>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+ return { \
+ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_##id##_0_comparable<RhsT>, \
+ std::is_same<LhsT, int>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
+
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )
+
+ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR
+
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op ) \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ ->std::enable_if_t< \
+ !std::is_arithmetic<std::remove_reference_t<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ ->std::enable_if_t<std::is_arithmetic<RhsT>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<)
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>)
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<=)
- CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>=)
CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
diff --git a/packages/Catch2/src/catch2/internal/catch_enforce.cpp b/packages/Catch2/src/catch2/internal/catch_enforce.cpp
index 4bc47ce3d3d91ed98a9bbb8d57c706448b358ffb..3f696406772fffedec57a19849ddb5dcd0c30564 100644
--- a/packages/Catch2/src/catch2/internal/catch_enforce.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_enforce.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_enforce.hpp b/packages/Catch2/src/catch2/internal/catch_enforce.hpp
index db52a0e2d29450ce42f3904a63f231eb5c0cb04a..076cea3c9e0f69d0a6f1b295115288f9f1ab86a6 100644
--- a/packages/Catch2/src/catch2/internal/catch_enforce.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_enforce.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_enum_values_registry.cpp b/packages/Catch2/src/catch2/internal/catch_enum_values_registry.cpp
index 32d0a16d96ebe6807fb6da7a8da9e21d1610103c..7e8bf5e5e3eb0841924a6fb6bcdaf2a99887d5cc 100644
--- a/packages/Catch2/src/catch2/internal/catch_enum_values_registry.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_enum_values_registry.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_enum_values_registry.hpp b/packages/Catch2/src/catch2/internal/catch_enum_values_registry.hpp
index 0c16a4c15d59fd52a9ee6eb9333f2063c5699d4b..999059ae8fa81339e77cfa04f6e8e12d65d661c1 100644
--- a/packages/Catch2/src/catch2/internal/catch_enum_values_registry.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_enum_values_registry.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_errno_guard.cpp b/packages/Catch2/src/catch2/internal/catch_errno_guard.cpp
index 95c192df0120e7ff168149cbd42438761e78f617..3bbf8b4c8303c28ef13f960d0a1b888d5932d138 100644
--- a/packages/Catch2/src/catch2/internal/catch_errno_guard.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_errno_guard.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_errno_guard.hpp b/packages/Catch2/src/catch2/internal/catch_errno_guard.hpp
index 9082c508559f62e898e7cce7d0a2b7ddf48c0702..df1237d53d3389e3739dc9fdd2f3d0513f00d21f 100644
--- a/packages/Catch2/src/catch2/internal/catch_errno_guard.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_errno_guard.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.cpp b/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.cpp
index acddea6ec99d796d699c01892bfcf34498f44891..f3d47c0cd6056fd815cf275ac4671d2dcd71261d 100644
--- a/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,8 +11,24 @@
#include <catch2/internal/catch_test_failure_exception.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
+#include <exception>
+
namespace Catch {
+ namespace {
+ static std::string tryTranslators(
+ std::vector<
+ Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
+ if ( translators.empty() ) {
+ std::rethrow_exception( std::current_exception() );
+ } else {
+ return translators[0]->translate( translators.begin() + 1,
+ translators.end() );
+ }
+ }
+
+ }
+
ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
}
@@ -37,13 +53,16 @@ namespace Catch {
// First we try user-registered translators. If none of them can
// handle the exception, it will be rethrown handled by our defaults.
try {
- return tryTranslators();
+ return tryTranslators(m_translators);
}
// To avoid having to handle TFE explicitly everywhere, we just
// rethrow it so that it goes back up the caller.
catch( TestFailureException& ) {
std::rethrow_exception(std::current_exception());
}
+ catch( TestSkipException& ) {
+ std::rethrow_exception(std::current_exception());
+ }
catch( std::exception const& ex ) {
return ex.what();
}
@@ -58,23 +77,10 @@ namespace Catch {
}
}
- std::string ExceptionTranslatorRegistry::tryTranslators() const {
- if (m_translators.empty()) {
- std::rethrow_exception(std::current_exception());
- } else {
- return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
- }
- }
-
#else // ^^ Exceptions are enabled // Exceptions are disabled vv
std::string ExceptionTranslatorRegistry::translateActiveException() const {
CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
}
-
- std::string ExceptionTranslatorRegistry::tryTranslators() const {
- CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
- }
#endif
-
}
diff --git a/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.hpp b/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.hpp
index 465796d35b8aecf61908480f561285fa1fc78131..3123e93d77788ec5f6a15337d921a05315342124 100644
--- a/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_exception_translator_registry.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -21,7 +21,6 @@ namespace Catch {
~ExceptionTranslatorRegistry() override;
void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
std::string translateActiveException() const override;
- std::string tryTranslators() const;
private:
ExceptionTranslators m_translators;
diff --git a/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.cpp b/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.cpp
index 3afd46f59fe0a352cf660afbdb0ae6f41b118017..f9702b1847aa0c1d45806e6dcf9f0251dff72c3c 100644
--- a/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.hpp b/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.hpp
index 389dab5d4c13ef9b63a08ff87294e3d347139147..ce07f9b6a7bd813190598a4642789398f990d3f4 100644
--- a/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_fatal_condition_handler.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.cpp b/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.cpp
index 55a95a2846740c9bd87a479e0b65a6a1ec6adb7c..e30ee43422ab870afe6ff17bfea08a6ad44848b2 100644
--- a/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.hpp b/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.hpp
index f121281390c745440f0303ddb79fefc898b7642c..ca883c613c1b625f8235d263c68c8763719b086f 100644
--- a/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_floating_point_helpers.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_getenv.cpp b/packages/Catch2/src/catch2/internal/catch_getenv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a9a592c7d9d1fa1b74a63c68b61c80df32840905
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_getenv.cpp
@@ -0,0 +1,37 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/internal/catch_getenv.hpp>
+
+#include <catch2/internal/catch_platform.hpp>
+#include <catch2/internal/catch_compiler_capabilities.hpp>
+
+#include <cstdlib>
+
+namespace Catch {
+ namespace Detail {
+
+#if !defined (CATCH_CONFIG_GETENV)
+ char const* getEnv( char const* ) { return nullptr; }
+#else
+
+ char const* getEnv( char const* varName ) {
+# if defined( _MSC_VER )
+# pragma warning( push )
+# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
+# endif
+
+ return std::getenv( varName );
+
+# if defined( _MSC_VER )
+# pragma warning( pop )
+# endif
+ }
+#endif
+} // namespace Detail
+} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_getenv.hpp b/packages/Catch2/src/catch2/internal/catch_getenv.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..31ef797446eaeb0cbe2056754ac1ad46ebfc205d
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_getenv.hpp
@@ -0,0 +1,20 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_GETENV_HPP_INCLUDED
+#define CATCH_GETENV_HPP_INCLUDED
+
+namespace Catch {
+namespace Detail {
+
+ //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
+ char const* getEnv(char const* varName);
+
+}
+}
+
+#endif // CATCH_GETENV_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_is_permutation.hpp b/packages/Catch2/src/catch2/internal/catch_is_permutation.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..708053d35c933d64cb3c0c137b3c09d9a1451ac8
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_is_permutation.hpp
@@ -0,0 +1,138 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
+#define CATCH_IS_PERMUTATION_HPP_INCLUDED
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+ namespace Detail {
+
+ template <typename ForwardIter,
+ typename Sentinel,
+ typename T,
+ typename Comparator>
+ ForwardIter find_sentinel( ForwardIter start,
+ Sentinel sentinel,
+ T const& value,
+ Comparator cmp ) {
+ while ( start != sentinel ) {
+ if ( cmp( *start, value ) ) { break; }
+ ++start;
+ }
+ return start;
+ }
+
+ template <typename ForwardIter,
+ typename Sentinel,
+ typename T,
+ typename Comparator>
+ std::ptrdiff_t count_sentinel( ForwardIter start,
+ Sentinel sentinel,
+ T const& value,
+ Comparator cmp ) {
+ std::ptrdiff_t count = 0;
+ while ( start != sentinel ) {
+ if ( cmp( *start, value ) ) { ++count; }
+ ++start;
+ }
+ return count;
+ }
+
+ template <typename ForwardIter, typename Sentinel>
+ std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
+ std::ptrdiff_t>
+ sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
+ std::ptrdiff_t dist = 0;
+ while ( iter != sentinel ) {
+ ++iter;
+ ++dist;
+ }
+ return dist;
+ }
+
+ template <typename ForwardIter>
+ std::ptrdiff_t sentinel_distance( ForwardIter first,
+ ForwardIter last ) {
+ return std::distance( first, last );
+ }
+
+ template <typename ForwardIter1,
+ typename Sentinel1,
+ typename ForwardIter2,
+ typename Sentinel2,
+ typename Comparator>
+ bool check_element_counts( ForwardIter1 first_1,
+ const Sentinel1 end_1,
+ ForwardIter2 first_2,
+ const Sentinel2 end_2,
+ Comparator cmp ) {
+ auto cursor = first_1;
+ while ( cursor != end_1 ) {
+ if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
+ cursor ) {
+ // we haven't checked this element yet
+ const auto count_in_range_2 =
+ count_sentinel( first_2, end_2, *cursor, cmp );
+ // Not a single instance in 2nd range, so it cannot be a
+ // permutation of 1st range
+ if ( count_in_range_2 == 0 ) { return false; }
+
+ const auto count_in_range_1 =
+ count_sentinel( cursor, end_1, *cursor, cmp );
+ if ( count_in_range_1 != count_in_range_2 ) {
+ return false;
+ }
+ }
+
+ ++cursor;
+ }
+
+ return true;
+ }
+
+ template <typename ForwardIter1,
+ typename Sentinel1,
+ typename ForwardIter2,
+ typename Sentinel2,
+ typename Comparator>
+ bool is_permutation( ForwardIter1 first_1,
+ const Sentinel1 end_1,
+ ForwardIter2 first_2,
+ const Sentinel2 end_2,
+ Comparator cmp ) {
+ // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
+ // TODO: Comparator has to be "both sides", e.g. a == b => b == a
+ // This skips shared prefix of the two ranges
+ while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
+ ++first_1;
+ ++first_2;
+ }
+
+ // We need to handle case where at least one of the ranges has no more elements
+ if (first_1 == end_1 || first_2 == end_2) {
+ return first_1 == end_1 && first_2 == end_2;
+ }
+
+ // pair counting is n**2, so we pay linear walk to compare the sizes first
+ auto dist_1 = sentinel_distance( first_1, end_1 );
+ auto dist_2 = sentinel_distance( first_2, end_2 );
+
+ if (dist_1 != dist_2) { return false; }
+
+ // Since we do not try to handle stronger iterators pair (e.g.
+ // bidir) optimally, the only thing left to do is to check counts in
+ // the remaining ranges.
+ return check_element_counts( first_1, end_1, first_2, end_2, cmp );
+ }
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_istream.cpp b/packages/Catch2/src/catch2/internal/catch_istream.cpp
index 4cd3505847e4045359eae043df1d06d38e7c90bb..bf0f66e42320d18480531076b19b14774472b318 100644
--- a/packages/Catch2/src/catch2/internal/catch_istream.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_istream.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -24,7 +24,7 @@ namespace Catch {
namespace Detail {
namespace {
template<typename WriterF, std::size_t bufferSize=256>
- class StreamBufImpl : public std::streambuf {
+ class StreamBufImpl final : public std::streambuf {
char data[bufferSize];
WriterF m_writer;
@@ -72,12 +72,13 @@ namespace Detail {
///////////////////////////////////////////////////////////////////////////
- class FileStream : public IStream {
+ class FileStream final : public IStream {
std::ofstream m_ofs;
public:
FileStream( std::string const& filename ) {
m_ofs.open( filename.c_str() );
CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
+ m_ofs << std::unitbuf;
}
~FileStream() override = default;
public: // IStream
@@ -88,7 +89,7 @@ namespace Detail {
///////////////////////////////////////////////////////////////////////////
- class CoutStream : public IStream {
+ class CoutStream final : public IStream {
std::ostream m_os;
public:
// Store the streambuf from cout up-front because
@@ -117,7 +118,7 @@ namespace Detail {
///////////////////////////////////////////////////////////////////////////
- class DebugOutStream : public IStream {
+ class DebugOutStream final : public IStream {
Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
std::ostream m_os;
public:
diff --git a/packages/Catch2/src/catch2/internal/catch_istream.hpp b/packages/Catch2/src/catch2/internal/catch_istream.hpp
index 629816c806cbd97654377fe7039f36ea11ac39ce..e6b9a2d3240401c9075bccf9ee7217206f683024 100644
--- a/packages/Catch2/src/catch2/internal/catch_istream.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_istream.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_lazy_expr.cpp b/packages/Catch2/src/catch2/internal/catch_lazy_expr.cpp
index 96ecf5c333476b32a76236bd50df76a02e30f770..56a5ae5e44519a7d43cea07aa7e846743267e1a9 100644
--- a/packages/Catch2/src/catch2/internal/catch_lazy_expr.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_lazy_expr.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_lazy_expr.hpp b/packages/Catch2/src/catch2/internal/catch_lazy_expr.hpp
index d4aa79d7be389e7716951fb190e3506f433f9219..36e0ac5002069b503ceb8dcfa8b07bef2ffe052f 100644
--- a/packages/Catch2/src/catch2/internal/catch_lazy_expr.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_lazy_expr.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_leak_detector.cpp b/packages/Catch2/src/catch2/internal/catch_leak_detector.cpp
index c9abbdfcdd1bc186b9f6bc3a091162f09fbf9678..7389eaf7787dc640f0a6e5817991ba0a548e307b 100644
--- a/packages/Catch2/src/catch2/internal/catch_leak_detector.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_leak_detector.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_leak_detector.hpp b/packages/Catch2/src/catch2/internal/catch_leak_detector.hpp
index eecdfca70d8d10d1395fefbcf8016f5d72464b75..94c8f32599113ce09724921399b75ff736905551 100644
--- a/packages/Catch2/src/catch2/internal/catch_leak_detector.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_leak_detector.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_list.cpp b/packages/Catch2/src/catch2/internal/catch_list.cpp
index 2c22745cefbc487d5f9993625569c604f502bc37..97e4c59315b7d74c40fcffa71215d583ab0a7776 100644
--- a/packages/Catch2/src/catch2/internal/catch_list.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_list.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -9,9 +9,9 @@
#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
#include <catch2/interfaces/catch_interfaces_reporter.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
-#include <catch2/interfaces/catch_interfaces_testcase.hpp>
#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
+#include <catch2/internal/catch_test_case_registry_impl.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
#include <catch2/internal/catch_case_insensitive_comparisons.hpp>
@@ -54,7 +54,7 @@ namespace Catch {
void listReporters(IEventListener& reporter) {
std::vector<ReporterDescription> descriptions;
- IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+ auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
descriptions.reserve(factories.size());
for (auto const& fac : factories) {
descriptions.push_back({ fac.first, fac.second->getDescription() });
diff --git a/packages/Catch2/src/catch2/internal/catch_list.hpp b/packages/Catch2/src/catch2/internal/catch_list.hpp
index 6fd759ea2f847130477f3f6427c7a9dd4265975a..9b4abd8249ac98790d91d8f0953e0b277602b52e 100644
--- a/packages/Catch2/src/catch2/internal/catch_list.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_list.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_logical_traits.hpp b/packages/Catch2/src/catch2/internal/catch_logical_traits.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd8756595db1f9c51d64e51a7994adeca5a5a302
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_logical_traits.hpp
@@ -0,0 +1,44 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+namespace Detail {
+
+#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
+
+ using std::conjunction;
+ using std::disjunction;
+ using std::negation;
+
+#else
+
+ template <class...> struct conjunction : std::true_type {};
+ template <class B1> struct conjunction<B1> : B1 {};
+ template <class B1, class... Bn>
+ struct conjunction<B1, Bn...>
+ : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
+
+ template <class...> struct disjunction : std::false_type {};
+ template <class B1> struct disjunction<B1> : B1 {};
+ template <class B1, class... Bn>
+ struct disjunction<B1, Bn...>
+ : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
+
+ template <class B>
+ struct negation : std::integral_constant<bool, !bool(B::value)> {};
+
+#endif
+
+} // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_main.cpp b/packages/Catch2/src/catch2/internal/catch_main.cpp
index a0126c231a008c51670a333c803085aac1ea051e..503b540f77ed4d46f3739b2f81f868420d40f108 100644
--- a/packages/Catch2/src/catch2/internal/catch_main.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_main.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_message_info.cpp b/packages/Catch2/src/catch2/internal/catch_message_info.cpp
index 11127e3f690086d3c686720a4fc78174117f02f8..e0e9dc7e5325b65c52223470619f071be3d70b67 100644
--- a/packages/Catch2/src/catch2/internal/catch_message_info.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_message_info.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_message_info.hpp b/packages/Catch2/src/catch2/internal/catch_message_info.hpp
index ecd78cabf8b9a95780c5fa7a5cee214d34fd6f56..1ef43fdaf00a6e47d2978f2f8837c4feb066ed39 100644
--- a/packages/Catch2/src/catch2/internal/catch_message_info.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_message_info.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,7 +10,7 @@
#include <catch2/internal/catch_result_type.hpp>
#include <catch2/internal/catch_source_line_info.hpp>
-#include <catch2/interfaces/catch_interfaces_capture.hpp>
+#include <catch2/internal/catch_stringref.hpp>
#include <string>
diff --git a/packages/Catch2/src/catch2/internal/catch_meta.hpp b/packages/Catch2/src/catch2/internal/catch_meta.hpp
index 7d573585904fab3280c9de11be6a8bfb2a571ee7..6fbc13a5d69749fbbd5439bd3f47fa1286b4a7b6 100644
--- a/packages/Catch2/src/catch2/internal/catch_meta.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_meta.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,15 +11,14 @@
#include <type_traits>
namespace Catch {
- template<typename T>
- struct always_false : std::false_type {};
+ template <typename>
+ struct true_given : std::true_type {};
- template <typename> struct true_given : std::true_type {};
struct is_callable_tester {
template <typename Fun, typename... Args>
- true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+ static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
template <typename...>
- std::false_type static test(...);
+ static std::false_type test(...);
};
template <typename T>
diff --git a/packages/Catch2/src/catch2/internal/catch_move_and_forward.hpp b/packages/Catch2/src/catch2/internal/catch_move_and_forward.hpp
index 01b7adae5decd5a7c80343a653d4067cbebf70ac..383d85cfeeee746dd79dc3fe6bad11f919f0658f 100644
--- a/packages/Catch2/src/catch2/internal/catch_move_and_forward.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_move_and_forward.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_noncopyable.hpp b/packages/Catch2/src/catch2/internal/catch_noncopyable.hpp
index f08b1578002bb40e5d532ac0f81becfe17c507ca..eb0823e8fe401756a822a12f1c067b9747317631 100644
--- a/packages/Catch2/src/catch2/internal/catch_noncopyable.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_noncopyable.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_optional.hpp b/packages/Catch2/src/catch2/internal/catch_optional.hpp
index 86eca344ce331840c4b0d5645986eec3b4a59354..d1e953ad994e67bab24dc4f627bc60ab0568a8f2 100644
--- a/packages/Catch2/src/catch2/internal/catch_optional.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_optional.hpp
@@ -1,13 +1,15 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_OPTIONAL_HPP_INCLUDED
#define CATCH_OPTIONAL_HPP_INCLUDED
+#include <catch2/internal/catch_move_and_forward.hpp>
+
#include <cassert>
namespace Catch {
@@ -16,35 +18,50 @@ namespace Catch {
template<typename T>
class Optional {
public:
- Optional() : nullableValue( nullptr ) {}
- Optional( T const& _value )
- : nullableValue( new( storage ) T( _value ) )
- {}
- Optional( Optional const& _other )
- : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
- {}
-
- ~Optional() {
+ Optional(): nullableValue( nullptr ) {}
+ ~Optional() { reset(); }
+
+ Optional( T const& _value ):
+ nullableValue( new ( storage ) T( _value ) ) {}
+ Optional( T&& _value ):
+ nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
+
+ Optional& operator=( T const& _value ) {
reset();
+ nullableValue = new ( storage ) T( _value );
+ return *this;
}
+ Optional& operator=( T&& _value ) {
+ reset();
+ nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
+ return *this;
+ }
+
+ Optional( Optional const& _other ):
+ nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
+ Optional( Optional&& _other ):
+ nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
+ : nullptr ) {}
- Optional& operator= ( Optional const& _other ) {
- if( &_other != this ) {
+ Optional& operator=( Optional const& _other ) {
+ if ( &_other != this ) {
reset();
- if( _other )
- nullableValue = new( storage ) T( *_other );
+ if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
}
return *this;
}
- Optional& operator = ( T const& _value ) {
- reset();
- nullableValue = new( storage ) T( _value );
+ Optional& operator=( Optional&& _other ) {
+ if ( &_other != this ) {
+ reset();
+ if ( _other ) {
+ nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
+ }
+ }
return *this;
}
void reset() {
- if( nullableValue )
- nullableValue->~T();
+ if ( nullableValue ) { nullableValue->~T(); }
nullableValue = nullptr;
}
@@ -91,7 +108,7 @@ namespace Catch {
}
private:
- T *nullableValue;
+ T* nullableValue;
alignas(alignof(T)) char storage[sizeof(T)];
};
diff --git a/packages/Catch2/src/catch2/internal/catch_output_redirect.cpp b/packages/Catch2/src/catch2/internal/catch_output_redirect.cpp
index ae0601412762d0a59e4829288971db5739dc2a6f..02f7c982689091ac57140e0e9df51ebec470c592 100644
--- a/packages/Catch2/src/catch2/internal/catch_output_redirect.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_output_redirect.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_output_redirect.hpp b/packages/Catch2/src/catch2/internal/catch_output_redirect.hpp
index d3463d992c0b957af0b56ad2fae580aed9ecbc8a..dc89223b922899226e304fe8d42ac4ad58e4597d 100644
--- a/packages/Catch2/src/catch2/internal/catch_output_redirect.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_output_redirect.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_parse_numbers.cpp b/packages/Catch2/src/catch2/internal/catch_parse_numbers.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d949ac19ba44d813d9c1cc6b63620f8c754a9e6b
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_parse_numbers.cpp
@@ -0,0 +1,52 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/internal/catch_compiler_capabilities.hpp>
+#include <catch2/internal/catch_parse_numbers.hpp>
+#include <catch2/internal/catch_string_manip.hpp>
+
+#include <limits>
+#include <stdexcept>
+
+namespace Catch {
+
+ Optional<unsigned int> parseUInt(std::string const& input, int base) {
+ auto trimmed = trim( input );
+ // std::stoull is annoying and accepts numbers starting with '-',
+ // it just negates them into unsigned int
+ if ( trimmed.empty() || trimmed[0] == '-' ) {
+ return {};
+ }
+
+ CATCH_TRY {
+ size_t pos = 0;
+ const auto ret = std::stoull( trimmed, &pos, base );
+
+ // We did not consume the whole input, so there is an issue
+ // This can be bunch of different stuff, like multiple numbers
+ // in the input, or invalid digits/characters and so on. Either
+ // way, we do not want to return the partially parsed result.
+ if ( pos != trimmed.size() ) {
+ return {};
+ }
+ // Too large
+ if ( ret > std::numeric_limits<unsigned int>::max() ) {
+ return {};
+ }
+ return static_cast<unsigned int>(ret);
+ }
+ CATCH_CATCH_ANON( std::invalid_argument const& ) {
+ // no conversion could be performed
+ }
+ CATCH_CATCH_ANON( std::out_of_range const& ) {
+ // the input does not fit into an unsigned long long
+ }
+ return {};
+ }
+
+} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_parse_numbers.hpp b/packages/Catch2/src/catch2/internal/catch_parse_numbers.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..3dabf95f18a2237de7077c06393e0cb3f400e1df
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_parse_numbers.hpp
@@ -0,0 +1,26 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
+#define CATCH_PARSE_NUMBERS_HPP_INCLUDED
+
+#include <catch2/internal/catch_optional.hpp>
+
+#include <string>
+
+namespace Catch {
+
+ /**
+ * Parses unsigned int from the input, using provided base
+ *
+ * Effectively a wrapper around std::stoul but with better error checking
+ * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
+ */
+ Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
+}
+
+#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_platform.hpp b/packages/Catch2/src/catch2/internal/catch_platform.hpp
index 01ee6cd9d39a56e1a7e186edf333aac479638ac2..b11d9ccde75c4ec2cefd815d083dd0741d51fd85 100644
--- a/packages/Catch2/src/catch2/internal/catch_platform.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_platform.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -28,6 +28,10 @@
# if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
# define CATCH_PLATFORM_WINDOWS_UWP
# endif
+
+#elif defined(__ORBIS__) || defined(__PROSPERO__)
+# define CATCH_PLATFORM_PLAYSTATION
+
#endif
#endif // CATCH_PLATFORM_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_polyfills.cpp b/packages/Catch2/src/catch2/internal/catch_polyfills.cpp
index 13e60f4a4d3195021ed2ecafdca53fb48739fcb4..96efad5dded864ba4c7e27c68caa451335fc88a8 100644
--- a/packages/Catch2/src/catch2/internal/catch_polyfills.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_polyfills.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_polyfills.hpp b/packages/Catch2/src/catch2/internal/catch_polyfills.hpp
index e8444836a72784ae7807bcf67732814cb8edb439..23a9332bc75dbd236efed770ba2aa74461f696db 100644
--- a/packages/Catch2/src/catch2/internal/catch_polyfills.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_polyfills.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_preprocessor.hpp b/packages/Catch2/src/catch2/internal/catch_preprocessor.hpp
index 4292d0df592a84b821d142151da5717faf78c289..08e844d2053d88393f83271d5d4b4c1163791da4 100644
--- a/packages/Catch2/src/catch2/internal/catch_preprocessor.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_preprocessor.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_preprocessor_internal_stringify.hpp b/packages/Catch2/src/catch2/internal/catch_preprocessor_internal_stringify.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2fd64e1c61576f05562b0c88e885749de8c41a6e
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_preprocessor_internal_stringify.hpp
@@ -0,0 +1,19 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+
+#include <catch2/catch_user_config.hpp>
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+ #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
+#else
+ #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
+#endif
+
+#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_preprocessor_remove_parens.hpp b/packages/Catch2/src/catch2/internal/catch_preprocessor_remove_parens.hpp
index 8033789083416c1ec673a19e4534af837b5644ca..dee11cd6a4177d4d5f5302a29a901d1478fd6038 100644
--- a/packages/Catch2/src/catch2/internal/catch_preprocessor_remove_parens.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_preprocessor_remove_parens.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_random_number_generator.cpp b/packages/Catch2/src/catch2/internal/catch_random_number_generator.cpp
index f71c2323a6e55c807d594160b3af3a328ca70ccd..6a79dff39a0fd380def5da040d6c63d9360a1d8b 100644
--- a/packages/Catch2/src/catch2/internal/catch_random_number_generator.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_random_number_generator.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_random_number_generator.hpp b/packages/Catch2/src/catch2/internal/catch_random_number_generator.hpp
index 6c4b028b239689bf965d13da82bbdce2b9651f84..e4129becf0596fcc1482cbd0d02c57adeee684ce 100644
--- a/packages/Catch2/src/catch2/internal/catch_random_number_generator.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_random_number_generator.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_random_seed_generation.cpp b/packages/Catch2/src/catch2/internal/catch_random_seed_generation.cpp
index 7fc1b90d4bfe9bb1cd8c29b230d7783f4efa8123..40c468cb4ba3d1debd3bb1db0f7755fe570cde51 100644
--- a/packages/Catch2/src/catch2/internal/catch_random_seed_generation.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_random_seed_generation.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_random_seed_generation.hpp b/packages/Catch2/src/catch2/internal/catch_random_seed_generation.hpp
index 42ca93db7d83de2c1e381fdd429b91dca7c97e02..d0d6fb245cb60cc34d2f7060e4708197f4762093 100644
--- a/packages/Catch2/src/catch2/internal/catch_random_seed_generation.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_random_seed_generation.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_reporter_registry.cpp b/packages/Catch2/src/catch2/internal/catch_reporter_registry.cpp
index 01b6b3a0ac9c935d20e140e8d0c8ea7d29099820..b2b0cd074da4a09f2c2ecbb7574417d69595e63f 100644
--- a/packages/Catch2/src/catch2/internal/catch_reporter_registry.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_reporter_registry.cpp
@@ -1,65 +1,88 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
-#include <catch2/internal/catch_reporter_registry.hpp>
-#include <catch2/reporters/catch_reporter_registrars.hpp>
+#include <catch2/internal/catch_reporter_registry.hpp>
+#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
+#include <catch2/internal/catch_enforce.hpp>
+#include <catch2/internal/catch_move_and_forward.hpp>
#include <catch2/reporters/catch_reporter_automake.hpp>
#include <catch2/reporters/catch_reporter_compact.hpp>
#include <catch2/reporters/catch_reporter_console.hpp>
#include <catch2/reporters/catch_reporter_junit.hpp>
+#include <catch2/reporters/catch_reporter_registrars.hpp>
#include <catch2/reporters/catch_reporter_sonarqube.hpp>
#include <catch2/reporters/catch_reporter_tap.hpp>
#include <catch2/reporters/catch_reporter_teamcity.hpp>
#include <catch2/reporters/catch_reporter_xml.hpp>
-#include <catch2/internal/catch_move_and_forward.hpp>
-#include <catch2/internal/catch_enforce.hpp>
namespace Catch {
+ struct ReporterRegistry::ReporterRegistryImpl {
+ std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
+ std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
+ factories;
+ };
- ReporterRegistry::ReporterRegistry() {
+ ReporterRegistry::ReporterRegistry():
+ m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
// Because it is impossible to move out of initializer list,
// we have to add the elements manually
- m_factories["Automake"] = Detail::make_unique<ReporterFactory<AutomakeReporter>>();
- m_factories["compact"] = Detail::make_unique<ReporterFactory<CompactReporter>>();
- m_factories["console"] = Detail::make_unique<ReporterFactory<ConsoleReporter>>();
- m_factories["JUnit"] = Detail::make_unique<ReporterFactory<JunitReporter>>();
- m_factories["SonarQube"] = Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
- m_factories["TAP"] = Detail::make_unique<ReporterFactory<TAPReporter>>();
- m_factories["TeamCity"] = Detail::make_unique<ReporterFactory<TeamCityReporter>>();
- m_factories["XML"] = Detail::make_unique<ReporterFactory<XmlReporter>>();
+ m_impl->factories["Automake"] =
+ Detail::make_unique<ReporterFactory<AutomakeReporter>>();
+ m_impl->factories["compact"] =
+ Detail::make_unique<ReporterFactory<CompactReporter>>();
+ m_impl->factories["console"] =
+ Detail::make_unique<ReporterFactory<ConsoleReporter>>();
+ m_impl->factories["JUnit"] =
+ Detail::make_unique<ReporterFactory<JunitReporter>>();
+ m_impl->factories["SonarQube"] =
+ Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
+ m_impl->factories["TAP"] =
+ Detail::make_unique<ReporterFactory<TAPReporter>>();
+ m_impl->factories["TeamCity"] =
+ Detail::make_unique<ReporterFactory<TeamCityReporter>>();
+ m_impl->factories["XML"] =
+ Detail::make_unique<ReporterFactory<XmlReporter>>();
}
ReporterRegistry::~ReporterRegistry() = default;
-
- IEventListenerPtr ReporterRegistry::create( std::string const& name, ReporterConfig&& config ) const {
- auto it = m_factories.find( name );
- if( it == m_factories.end() )
- return nullptr;
- return it->second->create( CATCH_MOVE(config) );
+ IEventListenerPtr
+ ReporterRegistry::create( std::string const& name,
+ ReporterConfig&& config ) const {
+ auto it = m_impl->factories.find( name );
+ if ( it == m_impl->factories.end() ) return nullptr;
+ return it->second->create( CATCH_MOVE( config ) );
}
- void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr factory ) {
+ void ReporterRegistry::registerReporter( std::string const& name,
+ IReporterFactoryPtr factory ) {
CATCH_ENFORCE( name.find( "::" ) == name.npos,
- "'::' is not allowed in reporter name: '" + name + '\'' );
- auto ret = m_factories.emplace(name, CATCH_MOVE(factory));
- CATCH_ENFORCE( ret.second, "reporter using '" + name + "' as name was already registered" );
+ "'::' is not allowed in reporter name: '" + name +
+ '\'' );
+ auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
+ CATCH_ENFORCE( ret.second,
+ "reporter using '" + name +
+ "' as name was already registered" );
}
void ReporterRegistry::registerListener(
Detail::unique_ptr<EventListenerFactory> factory ) {
- m_listeners.push_back( CATCH_MOVE(factory) );
+ m_impl->listeners.push_back( CATCH_MOVE( factory ) );
}
- IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
- return m_factories;
- }
- IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
- return m_listeners;
+ std::map<std::string,
+ IReporterFactoryPtr,
+ Detail::CaseInsensitiveLess> const&
+ ReporterRegistry::getFactories() const {
+ return m_impl->factories;
}
-}
+ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+ ReporterRegistry::getListeners() const {
+ return m_impl->listeners;
+ }
+} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_reporter_registry.hpp b/packages/Catch2/src/catch2/internal/catch_reporter_registry.hpp
index b0864265c285199b70694f612a9de51070cd7e02..92a889279346c1a01bc98d3bb989fc844172770f 100644
--- a/packages/Catch2/src/catch2/internal/catch_reporter_registry.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_reporter_registry.hpp
@@ -1,38 +1,55 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
+#include <catch2/internal/catch_case_insensitive_comparisons.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
#include <map>
+#include <string>
+#include <vector>
namespace Catch {
- class ReporterRegistry : public IReporterRegistry {
- public:
+ class IEventListener;
+ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+ class IReporterFactory;
+ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+ struct ReporterConfig;
+ class EventListenerFactory;
+
+ class ReporterRegistry {
+ struct ReporterRegistryImpl;
+ Detail::unique_ptr<ReporterRegistryImpl> m_impl;
+ public:
ReporterRegistry();
- ~ReporterRegistry() override; // = default, out of line to allow fwd decl
+ ~ReporterRegistry(); // = default;
- IEventListenerPtr create( std::string const& name, ReporterConfig&& config ) const override;
+ IEventListenerPtr create( std::string const& name,
+ ReporterConfig&& config ) const;
- void registerReporter( std::string const& name, IReporterFactoryPtr factory );
- void registerListener( Detail::unique_ptr<EventListenerFactory> factory );
+ void registerReporter( std::string const& name,
+ IReporterFactoryPtr factory );
- FactoryMap const& getFactories() const override;
- Listeners const& getListeners() const override;
+ void
+ registerListener( Detail::unique_ptr<EventListenerFactory> factory );
- private:
- FactoryMap m_factories;
- Listeners m_listeners;
+ std::map<std::string,
+ IReporterFactoryPtr,
+ Detail::CaseInsensitiveLess> const&
+ getFactories() const;
+
+ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+ getListeners() const;
};
-}
+
+} // end namespace Catch
#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.cpp b/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.cpp
index 30ee191c59ae1a253c1fa37ff49b5a667d0c2572..8b88b170a556162fbd7898085e4377f99d98ffd5 100644
--- a/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -21,9 +21,9 @@ namespace Catch {
};
kvPair splitKVPair(StringRef kvString) {
- auto splitPos = static_cast<size_t>( std::distance(
- kvString.begin(),
- std::find( kvString.begin(), kvString.end(), '=' ) ) );
+ auto splitPos = static_cast<size_t>(
+ std::find( kvString.begin(), kvString.end(), '=' ) -
+ kvString.begin() );
return { kvString.substr( 0, splitPos ),
kvString.substr( splitPos + 1, kvString.size() ) };
diff --git a/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.hpp b/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.hpp
index 242e10222335c34ec32362b07a7197e2bfa0e54c..d446ce98b4614e0c7c804c141e48d7d680316575 100644
--- a/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_reporter_spec_parser.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_result_type.cpp b/packages/Catch2/src/catch2/internal/catch_result_type.cpp
index 7dea5b4738f4caed1cd601683ac044f32a944867..6cedce7169206353546b631119f06368e459a8bb 100644
--- a/packages/Catch2/src/catch2/internal/catch_result_type.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_result_type.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_result_type.hpp b/packages/Catch2/src/catch2/internal/catch_result_type.hpp
index f0906fcd303d6dd7547f04780314af30bd2acc71..e66afaff005a43192aee01286b3c14185faa3333 100644
--- a/packages/Catch2/src/catch2/internal/catch_result_type.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_result_type.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -16,6 +16,8 @@ namespace Catch {
Ok = 0,
Info = 1,
Warning = 2,
+ // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
+ ExplicitSkip = 4,
FailureBit = 0x10,
diff --git a/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.cpp b/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.cpp
index 9b0824236a0f019e27d32611a8cafad6dc50b2b6..33eafde4ad9665782a2794a89c5593890f1efd9a 100644
--- a/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.hpp b/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.hpp
index 55cff727ecd5273ab19f37eff5832e27d484109b..5b864f35ca4af5f9521e05f79c3de75d2232de47 100644
--- a/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_reusable_string_stream.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_run_context.cpp b/packages/Catch2/src/catch2/internal/catch_run_context.cpp
index c8b0b30e399460dbcbdb4a8bd7c626fdbcd4f470..6f15cfb1a4bbf34767d357c3eb5deccc3d31a11e 100644
--- a/packages/Catch2/src/catch2/internal/catch_run_context.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_run_context.cpp
@@ -1,15 +1,16 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/internal/catch_run_context.hpp>
#include <catch2/catch_user_config.hpp>
-#include <catch2/interfaces/catch_interfaces_generatortracker.hpp>
#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/interfaces/catch_interfaces_generatortracker.hpp>
+#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/internal/catch_compiler_capabilities.hpp>
#include <catch2/internal/catch_context.hpp>
#include <catch2/internal/catch_enforce.hpp>
@@ -26,149 +27,152 @@
namespace Catch {
namespace Generators {
- struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
- GeneratorBasePtr m_generator;
-
- GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
- : TrackerBase( nameAndLocation, ctx, parent )
- {}
- ~GeneratorTracker() override;
-
- static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
- GeneratorTracker* tracker;
-
- ITracker& currentTracker = ctx.currentTracker();
- // Under specific circumstances, the generator we want
- // to acquire is also the current tracker. If this is
- // the case, we have to avoid looking through current
- // tracker's children, and instead return the current
- // tracker.
- // A case where this check is important is e.g.
- // for (int i = 0; i < 5; ++i) {
- // int n = GENERATE(1, 2);
- // }
- //
- // without it, the code above creates 5 nested generators.
- if ( currentTracker.nameAndLocation() == nameAndLocation ) {
- auto thisTracker =
- currentTracker.parent()->findChild( nameAndLocation );
- assert( thisTracker );
- assert( thisTracker->isGeneratorTracker() );
- tracker = static_cast<GeneratorTracker*>( thisTracker );
- } else if ( ITracker* childTracker =
- currentTracker.findChild( nameAndLocation ) ) {
- assert( childTracker );
- assert( childTracker->isGeneratorTracker() );
- tracker = static_cast<GeneratorTracker*>( childTracker );
- } else {
- auto newTracker =
- Catch::Detail::make_unique<GeneratorTracker>(
- nameAndLocation, ctx, ¤tTracker );
- tracker = newTracker.get();
- currentTracker.addChild( CATCH_MOVE(newTracker) );
- }
-
- if( !tracker->isComplete() ) {
- tracker->open();
- }
+ namespace {
+ struct GeneratorTracker final : TestCaseTracking::TrackerBase,
+ IGeneratorTracker {
+ GeneratorBasePtr m_generator;
+
+ GeneratorTracker(
+ TestCaseTracking::NameAndLocation&& nameAndLocation,
+ TrackerContext& ctx,
+ ITracker* parent ):
+ TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
+ ~GeneratorTracker() override = default;
+
+ static GeneratorTracker*
+ acquire( TrackerContext& ctx,
+ TestCaseTracking::NameAndLocationRef const&
+ nameAndLocation ) {
+ GeneratorTracker* tracker;
+
+ ITracker& currentTracker = ctx.currentTracker();
+ // Under specific circumstances, the generator we want
+ // to acquire is also the current tracker. If this is
+ // the case, we have to avoid looking through current
+ // tracker's children, and instead return the current
+ // tracker.
+ // A case where this check is important is e.g.
+ // for (int i = 0; i < 5; ++i) {
+ // int n = GENERATE(1, 2);
+ // }
+ //
+ // without it, the code above creates 5 nested generators.
+ if ( currentTracker.nameAndLocation() == nameAndLocation ) {
+ auto thisTracker = currentTracker.parent()->findChild(
+ nameAndLocation );
+ assert( thisTracker );
+ assert( thisTracker->isGeneratorTracker() );
+ tracker = static_cast<GeneratorTracker*>( thisTracker );
+ } else if ( ITracker* childTracker =
+ currentTracker.findChild(
+ nameAndLocation ) ) {
+ assert( childTracker );
+ assert( childTracker->isGeneratorTracker() );
+ tracker =
+ static_cast<GeneratorTracker*>( childTracker );
+ } else {
+ return nullptr;
+ }
- return *tracker;
- }
+ if ( !tracker->isComplete() ) { tracker->open(); }
- // TrackerBase interface
- bool isGeneratorTracker() const override { return true; }
- auto hasGenerator() const -> bool override {
- return !!m_generator;
- }
- void close() override {
- TrackerBase::close();
- // If a generator has a child (it is followed by a section)
- // and none of its children have started, then we must wait
- // until later to start consuming its values.
- // This catches cases where `GENERATE` is placed between two
- // `SECTION`s.
- // **The check for m_children.empty cannot be removed**.
- // doing so would break `GENERATE` _not_ followed by `SECTION`s.
- const bool should_wait_for_child = [&]() {
- // No children -> nobody to wait for
- if ( m_children.empty() ) {
- return false;
- }
- // If at least one child started executing, don't wait
- if ( std::find_if(
- m_children.begin(),
- m_children.end(),
- []( TestCaseTracking::ITrackerPtr const& tracker ) {
- return tracker->hasStarted();
- } ) != m_children.end() ) {
- return false;
- }
+ return tracker;
+ }
- // No children have started. We need to check if they _can_
- // start, and thus we should wait for them, or they cannot
- // start (due to filters), and we shouldn't wait for them
- ITracker* parent = m_parent;
- // This is safe: there is always at least one section
- // tracker in a test case tracking tree
- while ( !parent->isSectionTracker() ) {
- parent = parent->parent();
- }
- assert( parent &&
- "Missing root (test case) level section" );
-
- auto const& parentSection =
- static_cast<SectionTracker const&>( *parent );
- auto const& filters = parentSection.getFilters();
- // No filters -> no restrictions on running sections
- if ( filters.empty() ) {
- return true;
- }
+ // TrackerBase interface
+ bool isGeneratorTracker() const override { return true; }
+ auto hasGenerator() const -> bool override {
+ return !!m_generator;
+ }
+ void close() override {
+ TrackerBase::close();
+ // If a generator has a child (it is followed by a section)
+ // and none of its children have started, then we must wait
+ // until later to start consuming its values.
+ // This catches cases where `GENERATE` is placed between two
+ // `SECTION`s.
+ // **The check for m_children.empty cannot be removed**.
+ // doing so would break `GENERATE` _not_ followed by
+ // `SECTION`s.
+ const bool should_wait_for_child = [&]() {
+ // No children -> nobody to wait for
+ if ( m_children.empty() ) { return false; }
+ // If at least one child started executing, don't wait
+ if ( std::find_if(
+ m_children.begin(),
+ m_children.end(),
+ []( TestCaseTracking::ITrackerPtr const&
+ tracker ) {
+ return tracker->hasStarted();
+ } ) != m_children.end() ) {
+ return false;
+ }
- for ( auto const& child : m_children ) {
- if ( child->isSectionTracker() &&
- std::find(
- filters.begin(),
- filters.end(),
- static_cast<SectionTracker const&>( *child )
- .trimmedName() ) != filters.end() ) {
- return true;
+ // No children have started. We need to check if they
+ // _can_ start, and thus we should wait for them, or
+ // they cannot start (due to filters), and we shouldn't
+ // wait for them
+ ITracker* parent = m_parent;
+ // This is safe: there is always at least one section
+ // tracker in a test case tracking tree
+ while ( !parent->isSectionTracker() ) {
+ parent = parent->parent();
}
+ assert( parent &&
+ "Missing root (test case) level section" );
+
+ auto const& parentSection =
+ static_cast<SectionTracker const&>( *parent );
+ auto const& filters = parentSection.getFilters();
+ // No filters -> no restrictions on running sections
+ if ( filters.empty() ) { return true; }
+
+ for ( auto const& child : m_children ) {
+ if ( child->isSectionTracker() &&
+ std::find( filters.begin(),
+ filters.end(),
+ static_cast<SectionTracker const&>(
+ *child )
+ .trimmedName() ) !=
+ filters.end() ) {
+ return true;
+ }
+ }
+ return false;
+ }();
+
+ // This check is a bit tricky, because m_generator->next()
+ // has a side-effect, where it consumes generator's current
+ // value, but we do not want to invoke the side-effect if
+ // this generator is still waiting for any child to start.
+ assert( m_generator && "Tracker without generator" );
+ if ( should_wait_for_child ||
+ ( m_runState == CompletedSuccessfully &&
+ m_generator->countedNext() ) ) {
+ m_children.clear();
+ m_runState = Executing;
}
- return false;
- }();
-
- // This check is a bit tricky, because m_generator->next()
- // has a side-effect, where it consumes generator's current
- // value, but we do not want to invoke the side-effect if
- // this generator is still waiting for any child to start.
- if ( should_wait_for_child ||
- ( m_runState == CompletedSuccessfully &&
- m_generator->countedNext() ) ) {
- m_children.clear();
- m_runState = Executing;
}
- }
- // IGeneratorTracker interface
- auto getGenerator() const -> GeneratorBasePtr const& override {
- return m_generator;
- }
- void setGenerator( GeneratorBasePtr&& generator ) override {
- m_generator = CATCH_MOVE( generator );
- }
- };
- GeneratorTracker::~GeneratorTracker() = default;
+ // IGeneratorTracker interface
+ auto getGenerator() const -> GeneratorBasePtr const& override {
+ return m_generator;
+ }
+ void setGenerator( GeneratorBasePtr&& generator ) override {
+ m_generator = CATCH_MOVE( generator );
+ }
+ };
+ } // namespace
}
RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
: m_runInfo(_config->name()),
- m_context(getCurrentMutableContext()),
m_config(_config),
m_reporter(CATCH_MOVE(reporter)),
m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
{
- m_context.setResultCapture(this);
+ getCurrentMutableContext().setResultCapture( this );
m_reporter->testRunStarting(m_runInfo);
}
@@ -179,13 +183,8 @@ namespace Catch {
Totals RunContext::runTest(TestCaseHandle const& testCase) {
const Totals prevTotals = m_totals;
- std::string redirectedCout;
- std::string redirectedCerr;
-
auto const& testInfo = testCase.getTestCaseInfo();
-
m_reporter->testCaseStarting(testInfo);
-
m_activeTestCase = &testCase;
@@ -227,9 +226,11 @@ namespace Catch {
seedRng( *m_config );
uint64_t testRuns = 0;
+ std::string redirectedCout;
+ std::string redirectedCerr;
do {
m_trackerContext.startCycle();
- m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+ m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
m_reporter->testCasePartialStarting(testInfo, testRuns);
@@ -240,7 +241,7 @@ namespace Catch {
redirectedCerr += oneRunCerr;
const auto singleRunTotals = m_totals.delta(beforeRunTotals);
- auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, oneRunCout, oneRunCerr, aborting());
+ auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
++testRuns;
@@ -255,8 +256,8 @@ namespace Catch {
m_totals.testCases += deltaTotals.testCases;
m_reporter->testCaseEnded(TestCaseStats(testInfo,
deltaTotals,
- redirectedCout,
- redirectedCerr,
+ CATCH_MOVE(redirectedCout),
+ CATCH_MOVE(redirectedCerr),
aborting()));
m_activeTestCase = nullptr;
@@ -266,10 +267,13 @@ namespace Catch {
}
- void RunContext::assertionEnded(AssertionResult const & result) {
+ void RunContext::assertionEnded(AssertionResult&& result) {
if (result.getResultType() == ResultWas::Ok) {
m_totals.assertions.passed++;
m_lastAssertionPassed = true;
+ } else if (result.getResultType() == ResultWas::ExplicitSkip) {
+ m_totals.assertions.skipped++;
+ m_lastAssertionPassed = true;
} else if (!result.succeeded()) {
m_lastAssertionPassed = false;
if (result.isOk()) {
@@ -285,24 +289,36 @@ namespace Catch {
m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
- if (result.getResultType() != ResultWas::Warning)
+ if ( result.getResultType() != ResultWas::Warning ) {
m_messageScopes.clear();
+ }
// Reset working state
resetAssertionInfo();
- m_lastResult = result;
+ m_lastResult = CATCH_MOVE( result );
}
void RunContext::resetAssertionInfo() {
m_lastAssertionInfo.macroName = StringRef();
m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
}
- bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
- ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+ void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
+ m_reporter->assertionStarting( info );
+ }
+
+ bool RunContext::sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) {
+ ITracker& sectionTracker =
+ SectionTracker::acquire( m_trackerContext,
+ TestCaseTracking::NameAndLocationRef(
+ sectionName, sectionLineInfo ) );
+
if (!sectionTracker.isOpen())
return false;
m_activeSections.push_back(§ionTracker);
+ SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
m_reporter->sectionStarting(sectionInfo);
@@ -311,14 +327,39 @@ namespace Catch {
return true;
}
- auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+ IGeneratorTracker*
+ RunContext::acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) {
using namespace Generators;
- GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
- TestCaseTracking::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
+ GeneratorTracker* tracker = GeneratorTracker::acquire(
+ m_trackerContext,
+ TestCaseTracking::NameAndLocationRef(
+ generatorName, lineInfo ) );
m_lastAssertionInfo.lineInfo = lineInfo;
return tracker;
}
+ IGeneratorTracker* RunContext::createGeneratorTracker(
+ StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) {
+
+ auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
+ auto& currentTracker = m_trackerContext.currentTracker();
+ assert(
+ currentTracker.nameAndLocation() != nameAndLoc &&
+ "Trying to create tracker for a genreator that already has one" );
+
+ auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
+ CATCH_MOVE(nameAndLoc), m_trackerContext, ¤tTracker );
+ auto ret = newTracker.get();
+ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+
+ ret->setGenerator( CATCH_MOVE( generator ) );
+ ret->open();
+ return ret;
+ }
+
bool RunContext::testForMissingAssertions(Counts& assertions) {
if (assertions.total() != 0)
return false;
@@ -331,7 +372,7 @@ namespace Catch {
return true;
}
- void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+ void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions(assertions);
@@ -340,19 +381,20 @@ namespace Catch {
m_activeSections.pop_back();
}
- m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+ m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
m_messages.clear();
m_messageScopes.clear();
}
- void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
- if (m_unfinishedSections.empty())
+ void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
+ if ( m_unfinishedSections.empty() ) {
m_activeSections.back()->fail();
- else
+ } else {
m_activeSections.back()->close();
+ }
m_activeSections.pop_back();
- m_unfinishedSections.push_back(endInfo);
+ m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
}
void RunContext::benchmarkPreparing( StringRef name ) {
@@ -376,8 +418,8 @@ namespace Catch {
m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
}
- void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
- m_messageScopes.emplace_back( builder );
+ void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
+ m_messageScopes.emplace_back( CATCH_MOVE(builder) );
}
std::string RunContext::getCurrentTestName() const {
@@ -402,9 +444,9 @@ namespace Catch {
// Instead, fake a result data.
AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
tempResult.message = static_cast<std::string>(message);
- AssertionResult result(m_lastAssertionInfo, tempResult);
+ AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
- assertionEnded(result);
+ assertionEnded(CATCH_MOVE(result) );
handleUnfinishedSections();
@@ -414,7 +456,7 @@ namespace Catch {
Counts assertions;
assertions.failed = 1;
- SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
m_reporter->sectionEnded(testCaseSectionStats);
auto const& testInfo = m_activeTestCase->getTestCaseInfo();
@@ -475,6 +517,8 @@ namespace Catch {
duration = timer.getElapsedSeconds();
} CATCH_CATCH_ANON (TestFailureException&) {
// This just means the test was aborted due to failure
+ } CATCH_CATCH_ANON (TestSkipException&) {
+ // This just means the test was explicitly skipped
} CATCH_CATCH_ALL {
// Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
// are reported without translation at the point of origin.
@@ -491,7 +535,7 @@ namespace Catch {
m_messages.clear();
m_messageScopes.clear();
- SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
m_reporter->sectionEnded(testCaseSectionStats);
}
@@ -515,7 +559,7 @@ namespace Catch {
itEnd = m_unfinishedSections.rend();
it != itEnd;
++it)
- sectionEnded(*it);
+ sectionEnded(CATCH_MOVE(*it));
m_unfinishedSections.clear();
}
@@ -524,8 +568,6 @@ namespace Catch {
ITransientExpression const& expr,
AssertionReaction& reaction
) {
- m_reporter->assertionStarting( info );
-
bool negated = isFalseTest( info.resultDisposition );
bool result = expr.getResult() != negated;
@@ -551,10 +593,10 @@ namespace Catch {
m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( negated ) );
- AssertionResult assertionResult{ info, data };
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
- assertionEnded( assertionResult );
+ assertionEnded( CATCH_MOVE(assertionResult) );
}
void RunContext::handleMessage(
@@ -563,16 +605,22 @@ namespace Catch {
StringRef message,
AssertionReaction& reaction
) {
- m_reporter->assertionStarting( info );
-
m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( false ) );
data.message = static_cast<std::string>(message);
- AssertionResult assertionResult{ m_lastAssertionInfo, data };
- assertionEnded( assertionResult );
- if( !assertionResult.isOk() )
+ AssertionResult assertionResult{ m_lastAssertionInfo,
+ CATCH_MOVE( data ) };
+
+ const auto isOk = assertionResult.isOk();
+ assertionEnded( CATCH_MOVE(assertionResult) );
+ if ( !isOk ) {
populateReaction( reaction );
+ } else if ( resultType == ResultWas::ExplicitSkip ) {
+ // TODO: Need to handle this explicitly, as ExplicitSkip is
+ // considered "OK"
+ reaction.shouldSkip = true;
+ }
}
void RunContext::handleUnexpectedExceptionNotThrown(
AssertionInfo const& info,
@@ -583,15 +631,15 @@ namespace Catch {
void RunContext::handleUnexpectedInflightException(
AssertionInfo const& info,
- std::string const& message,
+ std::string&& message,
AssertionReaction& reaction
) {
m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
- data.message = message;
- AssertionResult assertionResult{ info, data };
- assertionEnded( assertionResult );
+ data.message = CATCH_MOVE(message);
+ AssertionResult assertionResult{ info, CATCH_MOVE(data) };
+ assertionEnded( CATCH_MOVE(assertionResult) );
populateReaction( reaction );
}
@@ -603,12 +651,13 @@ namespace Catch {
void RunContext::handleIncomplete(
AssertionInfo const& info
) {
+ using namespace std::string_literals;
m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
- data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
- AssertionResult assertionResult{ info, data };
- assertionEnded( assertionResult );
+ data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+ assertionEnded( CATCH_MOVE(assertionResult) );
}
void RunContext::handleNonExpr(
AssertionInfo const &info,
@@ -618,11 +667,11 @@ namespace Catch {
m_lastAssertionInfo = info;
AssertionResultData data( resultType, LazyExpression( false ) );
- AssertionResult assertionResult{ info, data };
- assertionEnded( assertionResult );
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
- if( !assertionResult.isOk() )
- populateReaction( reaction );
+ const auto isOk = assertionResult.isOk();
+ assertionEnded( CATCH_MOVE(assertionResult) );
+ if ( !isOk ) { populateReaction( reaction ); }
}
diff --git a/packages/Catch2/src/catch2/internal/catch_run_context.hpp b/packages/Catch2/src/catch2/internal/catch_run_context.hpp
index cf8941766a0469b21772b917d735b08c06494a76..c749304d3b5b4fe0fd95900680fdd24c2118e9d9 100644
--- a/packages/Catch2/src/catch2/internal/catch_run_context.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_run_context.hpp
@@ -1,15 +1,16 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
#define CATCH_RUN_CONTEXT_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
+#include <catch2/interfaces/catch_interfaces_capture.hpp>
#include <catch2/internal/catch_test_registry.hpp>
+#include <catch2/internal/catch_test_run_info.hpp>
#include <catch2/internal/catch_fatal_condition_handler.hpp>
#include <catch2/catch_test_case_info.hpp>
#include <catch2/catch_message.hpp>
@@ -24,13 +25,14 @@
namespace Catch {
- class IMutableContext;
class IGeneratorTracker;
class IConfig;
+ class IEventListener;
+ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
///////////////////////////////////////////////////////////////////////////
- class RunContext : public IResultCapture {
+ class RunContext final : public IResultCapture {
public:
RunContext( RunContext const& ) = delete;
@@ -59,7 +61,7 @@ namespace Catch {
AssertionReaction& reaction ) override;
void handleUnexpectedInflightException
( AssertionInfo const& info,
- std::string const& message,
+ std::string&& message,
AssertionReaction& reaction ) override;
void handleIncomplete
( AssertionInfo const& info ) override;
@@ -68,12 +70,22 @@ namespace Catch {
ResultWas::OfType resultType,
AssertionReaction &reaction ) override;
- bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+ void notifyAssertionStarted( AssertionInfo const& info ) override;
+ bool sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) override;
- void sectionEnded( SectionEndInfo const& endInfo ) override;
- void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+ void sectionEnded( SectionEndInfo&& endInfo ) override;
+ void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
+
+ IGeneratorTracker*
+ acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) override;
+ IGeneratorTracker* createGeneratorTracker(
+ StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) override;
- auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
void benchmarkPreparing( StringRef name ) override;
void benchmarkStarting( BenchmarkInfo const& info ) override;
@@ -83,7 +95,7 @@ namespace Catch {
void pushScopedMessage( MessageInfo const& message ) override;
void popScopedMessage( MessageInfo const& message ) override;
- void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+ void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
std::string getCurrentTestName() const override;
@@ -109,7 +121,7 @@ namespace Catch {
void resetAssertionInfo();
bool testForMissingAssertions( Counts& assertions );
- void assertionEnded( AssertionResult const& result );
+ void assertionEnded( AssertionResult&& result );
void reportExpr
( AssertionInfo const &info,
ResultWas::OfType resultType,
@@ -123,7 +135,6 @@ namespace Catch {
void handleUnfinishedSections();
TestRunInfo m_runInfo;
- IMutableContext& m_context;
TestCaseHandle const* m_activeTestCase = nullptr;
ITracker* m_testCaseTracker = nullptr;
Optional<AssertionResult> m_lastResult;
diff --git a/packages/Catch2/src/catch2/internal/catch_section.cpp b/packages/Catch2/src/catch2/internal/catch_section.cpp
index 8f37e27491545c00ef7cd5da9aaf1935ec5b765e..061732b1d875c4433eb8c11632b434786a6d6ac6 100644
--- a/packages/Catch2/src/catch2/internal/catch_section.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_section.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -15,7 +15,7 @@ namespace Catch {
Section::Section( SectionInfo&& info ):
m_info( CATCH_MOVE( info ) ),
m_sectionIncluded(
- getResultCapture().sectionStarted( m_info, m_assertions ) ) {
+ getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
// Non-"included" sections will not use the timing information
// anyway, so don't bother with the potential syscall.
if (m_sectionIncluded) {
@@ -23,13 +23,31 @@ namespace Catch {
}
}
+ Section::Section( SourceLineInfo const& _lineInfo,
+ StringRef _name,
+ const char* const ):
+ m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
+ m_sectionIncluded(
+ getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
+ // We delay initialization the SectionInfo member until we know
+ // this section needs it, so we avoid allocating std::string for name.
+ // We also delay timer start to avoid the potential syscall unless we
+ // will actually use the result.
+ if ( m_sectionIncluded ) {
+ m_info.name = static_cast<std::string>( _name );
+ m_info.lineInfo = _lineInfo;
+ m_timer.start();
+ }
+ }
+
Section::~Section() {
if( m_sectionIncluded ) {
- SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
- if( uncaught_exceptions() )
- getResultCapture().sectionEndedEarly( endInfo );
- else
- getResultCapture().sectionEnded( endInfo );
+ SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
+ if ( uncaught_exceptions() ) {
+ getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
+ } else {
+ getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
+ }
}
}
diff --git a/packages/Catch2/src/catch2/internal/catch_section.hpp b/packages/Catch2/src/catch2/internal/catch_section.hpp
index 2e72923c3a1a267752a5b4d6f77565d20a2d6863..bd92bdf462b03e37aca9966bb6e6c09ac79b11ba 100644
--- a/packages/Catch2/src/catch2/internal/catch_section.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_section.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -9,6 +9,7 @@
#define CATCH_SECTION_HPP_INCLUDED
#include <catch2/internal/catch_compiler_capabilities.hpp>
+#include <catch2/internal/catch_config_static_analysis_support.hpp>
#include <catch2/internal/catch_noncopyable.hpp>
#include <catch2/catch_section_info.hpp>
#include <catch2/catch_timer.hpp>
@@ -20,6 +21,9 @@ namespace Catch {
class Section : Detail::NonCopyable {
public:
Section( SectionInfo&& info );
+ Section( SourceLineInfo const& _lineInfo,
+ StringRef _name,
+ const char* const = nullptr );
~Section();
// This indicates whether the section should be executed or not
@@ -35,16 +39,62 @@ namespace Catch {
} // end namespace Catch
-#define INTERNAL_CATCH_SECTION( ... ) \
- CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
- CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
- if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
- CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
-
-#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
- CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
- CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
- if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
- CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+# define INTERNAL_CATCH_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
+ catch_internal_Section ) = \
+ Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
+ catch_internal_Section ) = \
+ Catch::SectionInfo( \
+ CATCH_INTERNAL_LINEINFO, \
+ ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
+ .str() ) ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#else
+
+// These section definitions imply that at most one section at one level
+// will be intered (because only one section's __LINE__ can be equal to
+// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
+
+namespace Catch {
+ namespace Detail {
+ // Intentionally without linkage, as it should only be used as a dummy
+ // symbol for static analysis.
+ int GetNewSectionHint();
+ } // namespace Detail
+} // namespace Catch
+
+
+# define INTERNAL_CATCH_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ if ( [[maybe_unused]] int catchInternalPreviousSectionHint = \
+ catchInternalSectionHint, \
+ catchInternalSectionHint = Catch::Detail::GetNewSectionHint(); \
+ catchInternalPreviousSectionHint == __LINE__ ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ if ( [[maybe_unused]] int catchInternalPreviousSectionHint = \
+ catchInternalSectionHint, \
+ catchInternalSectionHint = Catch::Detail::GetNewSectionHint(); \
+ catchInternalPreviousSectionHint == __LINE__ ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#endif
+
#endif // CATCH_SECTION_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_sharding.hpp b/packages/Catch2/src/catch2/internal/catch_sharding.hpp
index 17a206f85070e8be43f7faa19b53ddd55e194ccb..d0e4cfa13fa62c98338cf9752732aaa3a8f9d40e 100644
--- a/packages/Catch2/src/catch2/internal/catch_sharding.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_sharding.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,6 +11,7 @@
#include <catch2/catch_session.hpp>
#include <cmath>
+#include <algorithm>
namespace Catch {
diff --git a/packages/Catch2/src/catch2/internal/catch_singletons.cpp b/packages/Catch2/src/catch2/internal/catch_singletons.cpp
index 116fce4698630727876b03af314f71ae1c268c09..4e856def35a7112f158df82a7e80b00735da23de 100644
--- a/packages/Catch2/src/catch2/internal/catch_singletons.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_singletons.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_singletons.hpp b/packages/Catch2/src/catch2/internal/catch_singletons.hpp
index d06d224487eff160b5d30d8c7385381b3b255ef1..a28a13daa5190113d64c0369d687adcbc1855403 100644
--- a/packages/Catch2/src/catch2/internal/catch_singletons.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_singletons.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_source_line_info.cpp b/packages/Catch2/src/catch2/internal/catch_source_line_info.cpp
index 9a4fe74e511b3b06f56119bd39246f59659eabaf..f55f1c9f4eb4a7ee74c26d4b039d07e06c2ba213 100644
--- a/packages/Catch2/src/catch2/internal/catch_source_line_info.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_source_line_info.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_source_line_info.hpp b/packages/Catch2/src/catch2/internal/catch_source_line_info.hpp
index c6b98195e1e4a4bb46ec36da9c6856a832fd2cb6..c59805277a0af4c9ec6d793ced1ca6e92d238265 100644
--- a/packages/Catch2/src/catch2/internal/catch_source_line_info.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_source_line_info.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.cpp b/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.cpp
index 7681f442acbf3bc51b74b6569827266bc9cbf6b0..1607663739251a0ff3b34e71e4d58c7a8284c3c8 100644
--- a/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.hpp b/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.hpp
index 943772b8ddd6eb57b4f56bd19a5787988e445205..aef4667d015b3f2efcf409c9887d50f5e6fc1619 100644
--- a/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_startup_exception_registry.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_stdstreams.cpp b/packages/Catch2/src/catch2/internal/catch_stdstreams.cpp
index 21a0e4e61b3c27fe667592b2d74c3615fa140958..a4502b2b85323760ccbad141ff036733c32ba1d5 100644
--- a/packages/Catch2/src/catch2/internal/catch_stdstreams.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_stdstreams.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_stdstreams.hpp b/packages/Catch2/src/catch2/internal/catch_stdstreams.hpp
index 39d8bd750bb6da16867642258ed6649ef99aa446..02aec63581461d2f70e074d2414d3ce36bf3c5da 100644
--- a/packages/Catch2/src/catch2/internal/catch_stdstreams.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_stdstreams.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_stream_end_stop.hpp b/packages/Catch2/src/catch2/internal/catch_stream_end_stop.hpp
index 452ca1e97357f30e26c2d584f4b4b856b1f7084e..66d678cf88bb84b3c2186362d4e6fc47b2e51e24 100644
--- a/packages/Catch2/src/catch2/internal/catch_stream_end_stop.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_stream_end_stop.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -17,10 +17,10 @@ namespace Catch {
// as well as
// << stuff +StreamEndStop
struct StreamEndStop {
- StringRef operator+() const { return StringRef(); }
+ constexpr StringRef operator+() const { return StringRef(); }
template <typename T>
- friend T const& operator+( T const& value, StreamEndStop ) {
+ constexpr friend T const& operator+( T const& value, StreamEndStop ) {
return value;
}
};
diff --git a/packages/Catch2/src/catch2/internal/catch_string_manip.cpp b/packages/Catch2/src/catch2/internal/catch_string_manip.cpp
index e61bfd434628c8f7b99915d399016b517e6dba1e..0c889ca1810c38de0426dbe36b7cc27cace07681 100644
--- a/packages/Catch2/src/catch2/internal/catch_string_manip.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_string_manip.cpp
@@ -1,14 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/internal/catch_string_manip.hpp>
#include <catch2/internal/catch_stringref.hpp>
-#include <algorithm>
#include <ostream>
#include <cstring>
#include <cctype>
@@ -32,9 +31,9 @@ namespace Catch {
return s.find( infix ) != std::string::npos;
}
void toLowerInPlace( std::string& s ) {
- std::transform( s.begin(), s.end(), s.begin(), []( char c ) {
- return toLower( c );
- } );
+ for ( char& c : s ) {
+ c = toLower( c );
+ }
}
std::string toLower( std::string const& s ) {
std::string lc = s;
diff --git a/packages/Catch2/src/catch2/internal/catch_string_manip.hpp b/packages/Catch2/src/catch2/internal/catch_string_manip.hpp
index dc58a33601e76504a583b51b38f14ff1c8dd4026..dc0c552c4ac996c7cb537417759a579885176ca9 100644
--- a/packages/Catch2/src/catch2/internal/catch_string_manip.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_string_manip.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,6 +10,7 @@
#include <catch2/internal/catch_stringref.hpp>
+#include <cstdint>
#include <string>
#include <iosfwd>
#include <vector>
diff --git a/packages/Catch2/src/catch2/internal/catch_stringref.cpp b/packages/Catch2/src/catch2/internal/catch_stringref.cpp
index 46bbfafdba598bd5945814015232ba32dc114d5c..232498ebe7fbab33d20af8a7452a61eca1bbe49a 100644
--- a/packages/Catch2/src/catch2/internal/catch_stringref.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_stringref.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -17,10 +17,6 @@ namespace Catch {
: StringRef( rawChars, std::strlen(rawChars) )
{}
- auto StringRef::operator == ( StringRef other ) const noexcept -> bool {
- return m_size == other.m_size
- && (std::memcmp( m_start, other.m_start, m_size ) == 0);
- }
bool StringRef::operator<(StringRef rhs) const noexcept {
if (m_size < rhs.m_size) {
diff --git a/packages/Catch2/src/catch2/internal/catch_stringref.hpp b/packages/Catch2/src/catch2/internal/catch_stringref.hpp
index e7f1ab70c14c8add9bdc2bc3f7156dc708d2070c..99bb9a986af71ddb3a0101a05a4e6f7eea6dfe4a 100644
--- a/packages/Catch2/src/catch2/internal/catch_stringref.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_stringref.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,6 +13,8 @@
#include <iosfwd>
#include <cassert>
+#include <cstring>
+
namespace Catch {
/// A non-owning string class (similar to the forthcoming std::string_view)
@@ -49,7 +51,10 @@ namespace Catch {
}
public: // operators
- auto operator == ( StringRef other ) const noexcept -> bool;
+ auto operator == ( StringRef other ) const noexcept -> bool {
+ return m_size == other.m_size
+ && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+ }
auto operator != (StringRef other) const noexcept -> bool {
return !(*this == other);
}
diff --git a/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.cpp b/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.cpp
index 8c3e339f6761894e0d272c1f18512f534ab78457..b7c6b9ec74312ba3e71bd121143796f533cc0c70 100644
--- a/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.hpp b/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.hpp
index 3dbe05281c1bdcc1c02c5409d251d90d0065fc52..64c0f8f3cdd5480930ce80fdc7e60a9bdf647b83 100644
--- a/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_tag_alias_registry.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_template_test_registry.hpp b/packages/Catch2/src/catch2/internal/catch_template_test_registry.hpp
index bfac3bc81d44ecbb24425aef0d23e33e11813ea5..0ea354bc6049b3e88b9d6f1b9a36f366cf749035 100644
--- a/packages/Catch2/src/catch2/internal/catch_template_test_registry.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_template_test_registry.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -74,6 +74,7 @@
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
@@ -84,12 +85,12 @@
struct TestName{\
TestName(){\
size_t index = 0; \
- constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
- using expander = size_t[];\
+ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+ using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
(void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
}\
};\
- static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+ static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
return 0;\
}();\
@@ -120,6 +121,7 @@
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
template<typename TestType> static void TestFuncName(); \
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
@@ -169,6 +171,7 @@
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
template<typename TestType> static void TestFunc(); \
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
@@ -178,7 +181,7 @@
void reg_tests() { \
size_t index = 0; \
using expander = size_t[]; \
- (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
} \
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
@@ -300,6 +303,7 @@
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
template<typename TestType> \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
void test();\
@@ -312,7 +316,7 @@
void reg_tests(){\
size_t index = 0;\
using expander = size_t[];\
- (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
}\
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
diff --git a/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.cpp b/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.cpp
index 692d066c4352011a015b8f578370e41c6323a41c..e1731ebe8bf997c6f350e3b20adc617db57cdcdb 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.hpp b/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.hpp
index afe233553171e085e88d9c75cf74c40b399ceda4..b0422dccd712fc764cc87e3eda63e2063290f86e 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_case_info_hasher.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.cpp b/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.cpp
index 6c491a959f27fa42e1a3b23103b609cf479081ed..f1702979e7c79b8fa78410778dc4d2ccd5df5811 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -9,6 +9,7 @@
#include <catch2/internal/catch_context.hpp>
#include <catch2/internal/catch_enforce.hpp>
+#include <catch2/interfaces/catch_interfaces_config.hpp>
#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
#include <catch2/internal/catch_random_number_generator.hpp>
#include <catch2/internal/catch_run_context.hpp>
@@ -23,6 +24,38 @@
namespace Catch {
+ namespace {
+ static void enforceNoDuplicateTestCases(
+ std::vector<TestCaseHandle> const& tests ) {
+ auto testInfoCmp = []( TestCaseInfo const* lhs,
+ TestCaseInfo const* rhs ) {
+ return *lhs < *rhs;
+ };
+ std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests(
+ testInfoCmp );
+ for ( auto const& test : tests ) {
+ const auto infoPtr = &test.getTestCaseInfo();
+ const auto prev = seenTests.insert( infoPtr );
+ CATCH_ENFORCE( prev.second,
+ "error: test case \""
+ << infoPtr->name << "\", with tags \""
+ << infoPtr->tagsAsString()
+ << "\" already defined.\n"
+ << "\tFirst seen at "
+ << ( *prev.first )->lineInfo << "\n"
+ << "\tRedefined at " << infoPtr->lineInfo );
+ }
+ }
+
+ static bool matchTest( TestCaseHandle const& testCase,
+ TestSpec const& testSpec,
+ IConfig const& config ) {
+ return testSpec.matches( testCase.getTestCaseInfo() ) &&
+ isThrowSafe( testCase, config );
+ }
+
+ } // end unnamed namespace
+
std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
switch (config.runOrder()) {
case TestRunOrder::Declared:
@@ -79,29 +112,6 @@ namespace Catch {
return !testCase.getTestCaseInfo().throws() || config.allowThrows();
}
- bool matchTest( TestCaseHandle const& testCase, TestSpec const& testSpec, IConfig const& config ) {
- return testSpec.matches( testCase.getTestCaseInfo() ) && isThrowSafe( testCase, config );
- }
-
- void
- enforceNoDuplicateTestCases( std::vector<TestCaseHandle> const& tests ) {
- auto testInfoCmp = []( TestCaseInfo const* lhs,
- TestCaseInfo const* rhs ) {
- return *lhs < *rhs;
- };
- std::set<TestCaseInfo const*, decltype(testInfoCmp)> seenTests(testInfoCmp);
- for ( auto const& test : tests ) {
- const auto infoPtr = &test.getTestCaseInfo();
- const auto prev = seenTests.insert( infoPtr );
- CATCH_ENFORCE(
- prev.second,
- "error: test case \"" << infoPtr->name << "\", with tags \""
- << infoPtr->tagsAsString() << "\" already defined.\n"
- << "\tFirst seen at " << ( *prev.first )->lineInfo << "\n"
- << "\tRedefined at " << infoPtr->lineInfo );
- }
- }
-
std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
std::vector<TestCaseHandle> filtered;
filtered.reserve( testCases.size() );
@@ -142,11 +152,4 @@ namespace Catch {
return m_sortedFunctions;
}
-
-
- ///////////////////////////////////////////////////////////////////////////
- void TestInvokerAsFunction::invoke() const {
- m_testAsFunction();
- }
-
} // end namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.hpp b/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.hpp
index b0064cbbdf8ae5487dd0957b03e11236c38f2c6d..a4a27ed122ddbc86c267ef42f902390c96f248b7 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_case_registry_impl.hpp
@@ -1,30 +1,29 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
-#include <catch2/internal/catch_test_registry.hpp>
+#include <catch2/interfaces/catch_interfaces_testcase.hpp>
#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/internal/catch_unique_ptr.hpp>
#include <vector>
namespace Catch {
- class TestCaseHandle;
class IConfig;
+ class ITestInvoker;
+ class TestCaseHandle;
class TestSpec;
std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );
bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
- bool matchTest( TestCaseHandle const& testCase, TestSpec const& testSpec, IConfig const& config );
-
- void enforceNoDuplicateTestCases( std::vector<TestCaseHandle> const& functions );
std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
@@ -53,18 +52,6 @@ namespace Catch {
///////////////////////////////////////////////////////////////////////////
- class TestInvokerAsFunction final : public ITestInvoker {
- using TestType = void(*)();
- TestType m_testAsFunction;
- public:
- TestInvokerAsFunction(TestType testAsFunction) noexcept:
- m_testAsFunction(testAsFunction) {}
-
- void invoke() const override;
- };
-
- ///////////////////////////////////////////////////////////////////////////
-
} // end namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_test_case_tracker.cpp b/packages/Catch2/src/catch2/internal/catch_test_case_tracker.cpp
index ce76dcba89287acaf63e6cc712c00f11c7439baf..1470b91c67434906657cfbed70e9b43e011b776e 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_case_tracker.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_case_tracker.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -22,8 +22,8 @@
namespace Catch {
namespace TestCaseTracking {
- NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
- : name( _name ),
+ NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
+ : name( CATCH_MOVE(_name) ),
location( _location )
{}
@@ -38,14 +38,17 @@ namespace TestCaseTracking {
m_children.push_back( CATCH_MOVE(child) );
}
- ITracker* ITracker::findChild( NameAndLocation const& nameAndLocation ) {
+ ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
auto it = std::find_if(
m_children.begin(),
m_children.end(),
[&nameAndLocation]( ITrackerPtr const& tracker ) {
- return tracker->nameAndLocation().location ==
- nameAndLocation.location &&
- tracker->nameAndLocation().name == nameAndLocation.name;
+ auto const& tnameAndLoc = tracker->nameAndLocation();
+ if ( tnameAndLoc.location.line !=
+ nameAndLocation.location.line ) {
+ return false;
+ }
+ return tnameAndLoc == nameAndLocation;
} );
return ( it != m_children.end() ) ? it->get() : nullptr;
}
@@ -53,10 +56,6 @@ namespace TestCaseTracking {
bool ITracker::isSectionTracker() const { return false; }
bool ITracker::isGeneratorTracker() const { return false; }
- bool ITracker::isSuccessfullyCompleted() const {
- return m_runState == CompletedSuccessfully;
- }
-
bool ITracker::isOpen() const {
return m_runState != NotStarted && !isComplete();
}
@@ -83,16 +82,6 @@ namespace TestCaseTracking {
return *m_rootTracker;
}
- void TrackerContext::endRun() {
- m_rootTracker.reset();
- m_currentTracker = nullptr;
- m_runState = NotStarted;
- }
-
- void TrackerContext::startCycle() {
- m_currentTracker = m_rootTracker.get();
- m_runState = Executing;
- }
void TrackerContext::completeCycle() {
m_runState = CompletedCycle;
}
@@ -100,16 +89,13 @@ namespace TestCaseTracking {
bool TrackerContext::completedCycle() const {
return m_runState == CompletedCycle;
}
- ITracker& TrackerContext::currentTracker() {
- return *m_currentTracker;
- }
void TrackerContext::setCurrentTracker( ITracker* tracker ) {
m_currentTracker = tracker;
}
- TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
- ITracker(nameAndLocation, parent),
+ TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
+ ITracker(CATCH_MOVE(nameAndLocation), parent),
m_ctx( ctx )
{}
@@ -169,13 +155,14 @@ namespace TestCaseTracking {
m_ctx.setCurrentTracker( this );
}
- SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
- : TrackerBase( nameAndLocation, ctx, parent ),
- m_trimmed_name(trim(nameAndLocation.name))
+ SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+ : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
+ m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
{
if( parent ) {
- while( !parent->isSectionTracker() )
+ while ( !parent->isSectionTracker() ) {
parent = parent->parent();
+ }
SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
addNextFilters( parentSection.m_filters );
@@ -195,24 +182,30 @@ namespace TestCaseTracking {
bool SectionTracker::isSectionTracker() const { return true; }
- SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
- SectionTracker* section;
+ SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
+ SectionTracker* tracker;
ITracker& currentTracker = ctx.currentTracker();
if ( ITracker* childTracker =
currentTracker.findChild( nameAndLocation ) ) {
assert( childTracker );
assert( childTracker->isSectionTracker() );
- section = static_cast<SectionTracker*>( childTracker );
+ tracker = static_cast<SectionTracker*>( childTracker );
} else {
- auto newSection = Catch::Detail::make_unique<SectionTracker>(
- nameAndLocation, ctx, ¤tTracker );
- section = newSection.get();
- currentTracker.addChild( CATCH_MOVE( newSection ) );
+ auto newTracker = Catch::Detail::make_unique<SectionTracker>(
+ NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
+ nameAndLocation.location },
+ ctx,
+ ¤tTracker );
+ tracker = newTracker.get();
+ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+ }
+
+ if ( !ctx.completedCycle() ) {
+ tracker->tryOpen();
}
- if( !ctx.completedCycle() )
- section->tryOpen();
- return *section;
+
+ return *tracker;
}
void SectionTracker::tryOpen() {
@@ -233,10 +226,6 @@ namespace TestCaseTracking {
m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
}
- std::vector<StringRef> const& SectionTracker::getFilters() const {
- return m_filters;
- }
-
StringRef SectionTracker::trimmedName() const {
return m_trimmed_name;
}
diff --git a/packages/Catch2/src/catch2/internal/catch_test_case_tracker.hpp b/packages/Catch2/src/catch2/internal/catch_test_case_tracker.hpp
index 0355f195cd006f83fbf712b4c935c87dea2e958e..50278c910fe332f0d3b5b1944db56aa8cbf03e39 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_case_tracker.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_case_tracker.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -22,10 +22,49 @@ namespace TestCaseTracking {
std::string name;
SourceLineInfo location;
- NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+ NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
- return lhs.name == rhs.name
- && lhs.location == rhs.location;
+ // This is a very cheap check that should have a very high hit rate.
+ // If we get to SourceLineInfo::operator==, we will redo it, but the
+ // cost of repeating is trivial at that point (we will be paying
+ // multiple strcmp/memcmps at that point).
+ if ( lhs.location.line != rhs.location.line ) { return false; }
+ return lhs.name == rhs.name && lhs.location == rhs.location;
+ }
+ friend bool operator!=(NameAndLocation const& lhs,
+ NameAndLocation const& rhs) {
+ return !( lhs == rhs );
+ }
+ };
+
+ /**
+ * This is a variant of `NameAndLocation` that does not own the name string
+ *
+ * This avoids extra allocations when trying to locate a tracker by its
+ * name and location, as long as we make sure that trackers only keep
+ * around the owning variant.
+ */
+ struct NameAndLocationRef {
+ StringRef name;
+ SourceLineInfo location;
+
+ constexpr NameAndLocationRef( StringRef name_,
+ SourceLineInfo location_ ):
+ name( name_ ), location( location_ ) {}
+
+ friend bool operator==( NameAndLocation const& lhs,
+ NameAndLocationRef const& rhs ) {
+ // This is a very cheap check that should have a very high hit rate.
+ // If we get to SourceLineInfo::operator==, we will redo it, but the
+ // cost of repeating is trivial at that point (we will be paying
+ // multiple strcmp/memcmps at that point).
+ if ( lhs.location.line != rhs.location.line ) { return false; }
+ return StringRef( lhs.name ) == rhs.name &&
+ lhs.location == rhs.location;
+ }
+ friend bool operator==( NameAndLocationRef const& lhs,
+ NameAndLocation const& rhs ) {
+ return rhs == lhs;
}
};
@@ -53,8 +92,8 @@ namespace TestCaseTracking {
CycleState m_runState = NotStarted;
public:
- ITracker( NameAndLocation const& nameAndLoc, ITracker* parent ):
- m_nameAndLocation( nameAndLoc ),
+ ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
+ m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
m_parent( parent )
{}
@@ -74,8 +113,10 @@ namespace TestCaseTracking {
//! Returns true if tracker run to completion (successfully or not)
virtual bool isComplete() const = 0;
- //! Returns true if tracker run to completion succesfully
- bool isSuccessfullyCompleted() const;
+ //! Returns true if tracker run to completion successfully
+ bool isSuccessfullyCompleted() const {
+ return m_runState == CompletedSuccessfully;
+ }
//! Returns true if tracker has started but hasn't been completed
bool isOpen() const;
//! Returns true iff tracker has started
@@ -93,7 +134,7 @@ namespace TestCaseTracking {
*
* Returns nullptr if not found.
*/
- ITracker* findChild( NameAndLocation const& nameAndLocation );
+ ITracker* findChild( NameAndLocationRef const& nameAndLocation );
//! Have any children been added?
bool hasChildren() const {
return !m_children.empty();
@@ -134,13 +175,15 @@ namespace TestCaseTracking {
public:
ITracker& startRun();
- void endRun();
- void startCycle();
+ void startCycle() {
+ m_currentTracker = m_rootTracker.get();
+ m_runState = Executing;
+ }
void completeCycle();
bool completedCycle() const;
- ITracker& currentTracker();
+ ITracker& currentTracker() { return *m_currentTracker; }
void setCurrentTracker( ITracker* tracker );
};
@@ -150,7 +193,7 @@ namespace TestCaseTracking {
TrackerContext& m_ctx;
public:
- TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+ TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
bool isComplete() const override;
@@ -166,22 +209,26 @@ namespace TestCaseTracking {
class SectionTracker : public TrackerBase {
std::vector<StringRef> m_filters;
- std::string m_trimmed_name;
+ // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
+ // Currently it allocates owns the name, so this is safe. If it is later refactored
+ // to not own the name, the name still has to outlive the `ITracker` parent, so
+ // this should still be safe.
+ StringRef m_trimmed_name;
public:
- SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+ SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
bool isSectionTracker() const override;
bool isComplete() const override;
- static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
+ static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );
void tryOpen();
void addInitialFilters( std::vector<std::string> const& filters );
void addNextFilters( std::vector<StringRef> const& filters );
//! Returns filters active in this tracker
- std::vector<StringRef> const& getFilters() const;
+ std::vector<StringRef> const& getFilters() const { return m_filters; }
//! Returns whitespace-trimmed name of the tracked section
StringRef trimmedName() const;
};
diff --git a/packages/Catch2/src/catch2/internal/catch_test_failure_exception.cpp b/packages/Catch2/src/catch2/internal/catch_test_failure_exception.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8ea313131378f1ed531c27e825900b6af209fbc9
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_test_failure_exception.cpp
@@ -0,0 +1,31 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/internal/catch_test_failure_exception.hpp>
+#include <catch2/internal/catch_enforce.hpp>
+#include <catch2/catch_user_config.hpp>
+
+namespace Catch {
+
+ void throw_test_failure_exception() {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+ throw TestFailureException{};
+#else
+ CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+ }
+
+ void throw_test_skip_exception() {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+ throw Catch::TestSkipException();
+#else
+ CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
+#endif
+ }
+
+} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_test_failure_exception.hpp b/packages/Catch2/src/catch2/internal/catch_test_failure_exception.hpp
index bb6803bae3c764167fa73c5ceda017266a7f91c7..1ef883648f28da5603aa4fa0478f744cb4211cc0 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_failure_exception.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_failure_exception.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -12,6 +12,22 @@ namespace Catch {
//! Used to signal that an assertion macro failed
struct TestFailureException{};
+ //! Used to signal that the remainder of a test should be skipped
+ struct TestSkipException {};
+
+ /**
+ * Outlines throwing of `TestFailureException` into a single TU
+ *
+ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+ */
+ [[noreturn]] void throw_test_failure_exception();
+
+ /**
+ * Outlines throwing of `TestSkipException` into a single TU
+ *
+ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+ */
+ [[noreturn]] void throw_test_skip_exception();
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_test_macro_impl.hpp b/packages/Catch2/src/catch2/internal/catch_test_macro_impl.hpp
index 95384bc155ab730b64ec02bbb9d089537eb762e4..39366023f426193457241be4d5c4dc079fa07374 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_macro_impl.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_macro_impl.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,6 +10,7 @@
#include <catch2/catch_user_config.hpp>
#include <catch2/internal/catch_assertion_handler.hpp>
+#include <catch2/internal/catch_preprocessor_internal_stringify.hpp>
#include <catch2/interfaces/catch_interfaces_capture.hpp>
#include <catch2/internal/catch_stringref.hpp>
#include <catch2/internal/catch_source_line_info.hpp>
@@ -22,12 +23,6 @@
#if !defined(CATCH_CONFIG_DISABLE)
-#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
- #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
-#else
- #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
-#endif
-
#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
///////////////////////////////////////////////////////////////////////////////
@@ -76,7 +71,10 @@
do { \
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
} \
catch( ... ) { \
@@ -91,7 +89,11 @@
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
if( catchAssertionHandler.allowThrows() ) \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( ... ) { \
@@ -108,7 +110,11 @@
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
if( catchAssertionHandler.allowThrows() ) \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(expr); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( exceptionType const& ) { \
@@ -131,11 +137,15 @@
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
if( catchAssertionHandler.allowThrows() ) \
try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( ... ) { \
- Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+ Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
} \
else \
catchAssertionHandler.handleThrowingCallSkipped(); \
diff --git a/packages/Catch2/src/catch2/internal/catch_test_registry.cpp b/packages/Catch2/src/catch2/internal/catch_test_registry.cpp
index faadb101b663132b5571b53a968399763ce27ba5..e9c999fecd73acc94802d739249e61c90a79d9d1 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_registry.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_registry.cpp
@@ -1,14 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/internal/catch_test_registry.hpp>
#include <catch2/internal/catch_compiler_capabilities.hpp>
#include <catch2/catch_test_case_info.hpp>
-#include <catch2/internal/catch_test_case_registry_impl.hpp>
#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
#include <catch2/internal/catch_string_manip.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
@@ -17,9 +16,10 @@
#include <iterator>
namespace Catch {
+ ITestInvoker::~ITestInvoker() = default;
namespace {
- StringRef extractClassName( StringRef classOrMethodName ) {
+ static StringRef extractClassName( StringRef classOrMethodName ) {
if ( !startsWith( classOrMethodName, '&' ) ) {
return classOrMethodName;
}
@@ -46,6 +46,18 @@ namespace Catch {
static_cast<std::size_t>( startIdx ),
static_cast<std::size_t>( classNameSize ) );
}
+
+ class TestInvokerAsFunction final : public ITestInvoker {
+ using TestType = void ( * )();
+ TestType m_testAsFunction;
+
+ public:
+ TestInvokerAsFunction( TestType testAsFunction ) noexcept:
+ m_testAsFunction( testAsFunction ) {}
+
+ void invoke() const override { m_testAsFunction(); }
+ };
+
} // namespace
Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
diff --git a/packages/Catch2/src/catch2/internal/catch_test_registry.hpp b/packages/Catch2/src/catch2/internal/catch_test_registry.hpp
index 6e064e0831416446c81ed95b4b8c63a1691bc727..d248d3cf904a6f90fb6813929a501bfcacf8281a 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_registry.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_registry.hpp
@@ -1,16 +1,17 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
#define CATCH_TEST_REGISTRY_HPP_INCLUDED
+#include <catch2/internal/catch_config_static_analysis_support.hpp>
#include <catch2/internal/catch_source_line_info.hpp>
#include <catch2/internal/catch_noncopyable.hpp>
-#include <catch2/interfaces/catch_interfaces_testcase.hpp>
+#include <catch2/interfaces/catch_interfaces_test_invoker.hpp>
#include <catch2/internal/catch_stringref.hpp>
#include <catch2/internal/catch_unique_ptr.hpp>
#include <catch2/internal/catch_unique_name.hpp>
@@ -72,25 +73,55 @@ struct AutoReg : Detail::NonCopyable {
void TestName::test()
#endif
+
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
static void TestName(); \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
- namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+ namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
static void TestName()
#define INTERNAL_CATCH_TESTCASE( ... ) \
INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )
- ///////////////////////////////////////////////////////////////////////////////
- #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
- CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
- CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
- CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
- namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
- CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#else // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+
+
+// Dummy registrator for the dumy test case macros
+namespace Catch {
+ namespace Detail {
+ struct DummyUse {
+ DummyUse( void ( * )( int ) );
+ };
+ } // namespace Detail
+} // namespace Catch
+
+// Note that both the presence of the argument and its exact name are
+// necessary for the section support.
+
+// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE`
+// tests can compile. The redefined `TEST_CASE` shadows this with param.
+static int catchInternalSectionHint = 0;
+
+# define INTERNAL_CATCH_TESTCASE2( fname ) \
+ static void fname( int ); \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME( \
+ dummyUser )( &fname ); \
+ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ static void fname( [[maybe_unused]] int catchInternalSectionHint ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+# define INTERNAL_CATCH_TESTCASE( ... ) \
+ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ) )
+
+
+#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
@@ -101,13 +132,33 @@ struct AutoReg : Detail::NonCopyable {
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
void test(); \
}; \
- Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+ Catch::makeTestInvoker( &TestName::test ), \
+ CATCH_INTERNAL_LINEINFO, \
+ #ClassName##_catch_sr, \
+ Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
} \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
void TestName::test()
#define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+
+ ///////////////////////////////////////////////////////////////////////////////
+ #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ namespace { \
+ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+ Catch::makeTestInvoker( &QualifiedMethod ), \
+ CATCH_INTERNAL_LINEINFO, \
+ "&" #QualifiedMethod##_catch_sr, \
+ Catch::NameAndTags{ __VA_ARGS__ } ); \
+ } /* NOLINT */ \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
do { \
diff --git a/packages/Catch2/src/catch2/internal/catch_test_run_info.hpp b/packages/Catch2/src/catch2/internal/catch_test_run_info.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..90357b0af53464289da25929c5452fb36b520a92
--- /dev/null
+++ b/packages/Catch2/src/catch2/internal/catch_test_run_info.hpp
@@ -0,0 +1,22 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
+#define CATCH_TEST_RUN_INFO_HPP_INCLUDED
+
+#include <catch2/internal/catch_stringref.hpp>
+
+namespace Catch {
+
+ struct TestRunInfo {
+ constexpr TestRunInfo(StringRef _name) : name(_name) {}
+ StringRef name;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/internal/catch_test_spec_parser.cpp b/packages/Catch2/src/catch2/internal/catch_test_spec_parser.cpp
index 4dd1ea2a17d3318657c66d6023b0654a8b3775da..d6e4cb58d1e1765d478c6f04bb35095c65c59ee2 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_spec_parser.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_spec_parser.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -221,10 +221,8 @@ namespace Catch {
token.erase(token.begin());
if (m_exclusion) {
m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
- m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
} else {
m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
- m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
}
}
if (m_exclusion) {
@@ -238,8 +236,4 @@ namespace Catch {
m_mode = None;
}
- TestSpec parseTestSpec( std::string const& arg ) {
- return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
- }
-
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_test_spec_parser.hpp b/packages/Catch2/src/catch2/internal/catch_test_spec_parser.hpp
index 75f2fd760c4c5e7d672f511610f71249a5636462..aa2917dbb2e7c677a07849fa737f9c546ef27053 100644
--- a/packages/Catch2/src/catch2/internal/catch_test_spec_parser.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_test_spec_parser.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -71,7 +71,6 @@ namespace Catch {
}
};
- TestSpec parseTestSpec( std::string const& arg );
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/internal/catch_textflow.cpp b/packages/Catch2/src/catch2/internal/catch_textflow.cpp
index 993e16229910d1c93f29e75f2407c6188548da25..7eac973258e8adcfc319d0e21b53217ea221a39b 100644
--- a/packages/Catch2/src/catch2/internal/catch_textflow.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_textflow.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_textflow.hpp b/packages/Catch2/src/catch2/internal/catch_textflow.hpp
index e2cdff58b7f9e0e9be2704cd5f044c0e525c1b28..0776ab9227d01f7ed99c11fcb771b57c3f778c0c 100644
--- a/packages/Catch2/src/catch2/internal/catch_textflow.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_textflow.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -59,7 +59,7 @@ namespace Catch {
// Calculates the length of the current line
void calcLength();
- // Returns current indention width
+ // Returns current indentation width
size_t indentSize() const;
// Creates an indented and (optionally) suffixed string from
diff --git a/packages/Catch2/src/catch2/internal/catch_to_string.hpp b/packages/Catch2/src/catch2/internal/catch_to_string.hpp
index 15b24e19534253ce9c0b52875fc7fed11fdc080b..c74621619c3b19fc64dc8e404ba6b3bddd63f0ea 100644
--- a/packages/Catch2/src/catch2/internal/catch_to_string.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_to_string.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.cpp b/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.cpp
index c6251a3f7cff4c669bed5ef2365d8892e500f844..704d6e1ca92cd9f70d36bc95224c34d59efe9f1b 100644
--- a/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.hpp b/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.hpp
index a287bacd87eb18527c6bd77431b9e59c8ad57f79..8520864cb1c73b8783b73168734fb50b771bcfe5 100644
--- a/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_uncaught_exceptions.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_unique_name.hpp b/packages/Catch2/src/catch2/internal/catch_unique_name.hpp
index 31ab91268416035c74ec0a1b66ff1a2625ac6f23..c6e1c2caac765cb79760fc04faf18ef563ed36aa 100644
--- a/packages/Catch2/src/catch2/internal/catch_unique_name.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_unique_name.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_unique_ptr.hpp b/packages/Catch2/src/catch2/internal/catch_unique_ptr.hpp
index c453cde623e0e846ca9c6c108974c5898fcfd2c0..49cbc7856d04ca1be345da8b38603ca3f7f6c12c 100644
--- a/packages/Catch2/src/catch2/internal/catch_unique_ptr.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_unique_ptr.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_void_type.hpp b/packages/Catch2/src/catch2/internal/catch_void_type.hpp
index 23875c352471cd07346eb70df6aa388749ec1ba0..dacc83dd1e47e547567300efcdc2cf3a48a88ec9 100644
--- a/packages/Catch2/src/catch2/internal/catch_void_type.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_void_type.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.cpp b/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.cpp
index d71ca37ac69e73b152923f8b9274aae81d41bac4..09c5a40597e66b9d5b19f5af82805669e0f8841c 100644
--- a/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.hpp b/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.hpp
index 6e9f6d57a7556d9f5a19008a5edd09f7c3812e75..72479ba87844ff9172f13a9c2c35dbb515dd98bb 100644
--- a/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_wildcard_pattern.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/internal/catch_windows_h_proxy.hpp b/packages/Catch2/src/catch2/internal/catch_windows_h_proxy.hpp
index 14fe747d1447fb37fc5fefc6440238190a99ed5e..e3b914955d8f13020801c86f85040384993ade76 100644
--- a/packages/Catch2/src/catch2/internal/catch_windows_h_proxy.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_windows_h_proxy.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -21,11 +21,7 @@
# define WIN32_LEAN_AND_MEAN
#endif
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
#include <windows.h>
-#endif
#endif // defined(CATCH_PLATFORM_WINDOWS)
diff --git a/packages/Catch2/src/catch2/internal/catch_xmlwriter.cpp b/packages/Catch2/src/catch2/internal/catch_xmlwriter.cpp
index 93758cba766ce7fb2d6c050f610e386ea01bb8d5..6c1d45df4891b7f553dd0add9aeff058eac86e3c 100644
--- a/packages/Catch2/src/catch2/internal/catch_xmlwriter.cpp
+++ b/packages/Catch2/src/catch2/internal/catch_xmlwriter.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,6 +11,7 @@
#include <catch2/internal/catch_enforce.hpp>
#include <catch2/internal/catch_xmlwriter.hpp>
+#include <cstdint>
#include <iomanip>
#include <type_traits>
diff --git a/packages/Catch2/src/catch2/internal/catch_xmlwriter.hpp b/packages/Catch2/src/catch2/internal/catch_xmlwriter.hpp
index 556339376d17f1d8972bfe63376bf8532aef57c7..ec55f3c46844c9a8f6dc00de1b3058ac9f0ed3cc 100644
--- a/packages/Catch2/src/catch2/internal/catch_xmlwriter.hpp
+++ b/packages/Catch2/src/catch2/internal/catch_xmlwriter.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers.cpp
index 6b604e4a18e38f84320249b7f6853d9f36e8a3d8..123b30413d302e4f74cb3de80eefeedd1e8dff84 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers.hpp
index 373e2a6739ef2af4eaa7e29df6f758b089fea4b6..3d996c39f229c5a11b875f2675d9581505515d84 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_all.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_all.hpp
index 3c0bb9f51c76d415b70e2f646161dd4e4d9a6dc4..83fe5386f68ff63340f0e4853d3dd444aae18d5e 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_all.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_all.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -27,6 +27,7 @@
#include <catch2/matchers/catch_matchers_floating_point.hpp>
#include <catch2/matchers/catch_matchers_predicate.hpp>
#include <catch2/matchers/catch_matchers_quantifiers.hpp>
+#include <catch2/matchers/catch_matchers_range_equals.hpp>
#include <catch2/matchers/catch_matchers_string.hpp>
#include <catch2/matchers/catch_matchers_templated.hpp>
#include <catch2/matchers/catch_matchers_vector.hpp>
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.cpp
index 5344abcd6c6544b1c371a44053ae994ef48f11f8..f0c535bcbf88a6dec8329b2709645a41188f41cb 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.hpp
index f0688a57af50105c55c44c7fc4074825e8877677..5f3fc7fbf715380ad8201bb453211141a24df165 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_container_properties.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_contains.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_contains.hpp
index 239aa80b96f71b855e69177b5950790793a2ce9e..877d6924dedff769511073356d89c2052e011ad1 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_contains.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_contains.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -33,13 +33,11 @@ namespace Catch {
}
template <typename RangeLike>
- bool match(RangeLike&& rng) const {
- using std::begin; using std::end;
-
- return end(rng) != std::find_if(begin(rng), end(rng),
- [&](auto const& elem) {
- return m_eq(elem, m_desired);
- });
+ bool match( RangeLike&& rng ) const {
+ for ( auto&& elem : rng ) {
+ if ( m_eq( elem, m_desired ) ) { return true; }
+ }
+ return false;
}
};
@@ -91,7 +89,7 @@ namespace Catch {
/**
* Creates a matcher that checks whether a range contains a specific element.
*
- * Uses `eq` to do the comparisons
+ * Uses `eq` to do the comparisons, the element is provided on the rhs
*/
template <typename T, typename Equality>
ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_exception.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers_exception.cpp
index af3ea15a6dd079905d315fe27941f29916230a7f..8147390bff69006ddfcd7d6e4d3f96854bfec60e 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_exception.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_exception.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_exception.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_exception.hpp
index eca9327d3b433a7371e3b339028463bf2358ec02..e7c3a636b1ce201a0841273251be3ba4a8c11782 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_exception.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_exception.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -29,6 +29,32 @@ public:
//! Creates a matcher that checks whether a std derived exception has the provided message
ExceptionMessageMatcher Message(std::string const& message);
+template <typename StringMatcherType>
+class ExceptionMessageMatchesMatcher final
+ : public MatcherBase<std::exception> {
+ StringMatcherType m_matcher;
+
+public:
+ ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
+ m_matcher( CATCH_MOVE( matcher ) ) {}
+
+ bool match( std::exception const& ex ) const override {
+ return m_matcher.match( ex.what() );
+ }
+
+ std::string describe() const override {
+ return " matches \"" + m_matcher.describe() + '"';
+ }
+};
+
+//! Creates a matcher that checks whether a message from an std derived
+//! exception matches a provided matcher
+template <typename StringMatcherType>
+ExceptionMessageMatchesMatcher<StringMatcherType>
+MessageMatches( StringMatcherType&& matcher ) {
+ return { CATCH_FORWARD( matcher ) };
+}
+
} // namespace Matchers
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.cpp
index 4d40140fea2bdb108e51958730a1c7401c7b95f4..6e596466ecabf20b88881aecd049c0114862d561 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -225,5 +225,17 @@ WithinRelMatcher WithinRel(float target) {
}
-} // namespace Matchers
+
+bool IsNaNMatcher::match( double const& matchee ) const {
+ return std::isnan( matchee );
+}
+
+std::string IsNaNMatcher::describe() const {
+ using namespace std::string_literals;
+ return "is NaN"s;
+}
+
+IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
+
+ } // namespace Matchers
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.hpp
index 99572e4332cad6c7328156f2de8dc4155cde0a37..76816633c8dcfe21375c7197ffb677436808b6ef 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_floating_point.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -27,6 +27,11 @@ namespace Matchers {
double m_margin;
};
+ //! Creates a matcher that accepts numbers within certain range of target
+ WithinAbsMatcher WithinAbs( double target, double margin );
+
+
+
class WithinUlpsMatcher final : public MatcherBase<double> {
public:
WithinUlpsMatcher( double target,
@@ -40,6 +45,13 @@ namespace Matchers {
Detail::FloatingPointKind m_type;
};
+ //! Creates a matcher that accepts doubles within certain ULP range of target
+ WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+ //! Creates a matcher that accepts floats within certain ULP range of target
+ WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+
+
+
// Given IEEE-754 format for floats and doubles, we can assume
// that float -> double promotion is lossless. Given this, we can
// assume that if we do the standard relative comparison of
@@ -56,13 +68,6 @@ namespace Matchers {
double m_epsilon;
};
- //! Creates a matcher that accepts doubles within certain ULP range of target
- WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
- //! Creates a matcher that accepts floats within certain ULP range of target
- WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
- //! Creates a matcher that accepts numbers within certain range of target
- WithinAbsMatcher WithinAbs(double target, double margin);
-
//! Creates a matcher that accepts doubles within certain relative range of target
WithinRelMatcher WithinRel(double target, double eps);
//! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
@@ -72,6 +77,17 @@ namespace Matchers {
//! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
WithinRelMatcher WithinRel(float target);
+
+
+ class IsNaNMatcher final : public MatcherBase<double> {
+ public:
+ IsNaNMatcher() = default;
+ bool match( double const& matchee ) const override;
+ std::string describe() const override;
+ };
+
+ IsNaNMatcher IsNaN();
+
} // namespace Matchers
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.cpp
index a9ecffc9fb0edd095b89e6644f751b10566724a2..f5445375cd2a9524cd135df9f927d41aaae2af69 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.hpp
index 5f5cea590137927288b535c432a6ebe8685980f1..2d1cc33a47d8ed2cd689aacb7fcaaa1fc69d2b52 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_predicate.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.cpp
index 1f2e48d8758c16e91460a116baf3186a08be15e7..5a7524672bd0d4fbe4dc474285d753eb2fe824fc 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.hpp
index 8833440f28f88a301b22759ace1f1411c51cdb77..977b0c762c7e803b36dd9b86a60f308335bd6e01 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_quantifiers.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_range_equals.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_range_equals.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..95b781a430f13675b027e21af4368922ea58524a
--- /dev/null
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_range_equals.hpp
@@ -0,0 +1,144 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+
+#include <catch2/internal/catch_is_permutation.hpp>
+#include <catch2/matchers/catch_matchers_templated.hpp>
+
+#include <algorithm>
+#include <utility>
+
+namespace Catch {
+ namespace Matchers {
+
+ /**
+ * Matcher for checking that an element contains the same
+ * elements in the same order
+ */
+ template <typename TargetRangeLike, typename Equality>
+ class RangeEqualsMatcher final : public MatcherGenericBase {
+ TargetRangeLike m_desired;
+ Equality m_predicate;
+
+ public:
+ template <typename TargetRangeLike2, typename Equality2>
+ RangeEqualsMatcher( TargetRangeLike2&& range,
+ Equality2&& predicate ):
+ m_desired( CATCH_FORWARD( range ) ),
+ m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+ template <typename RangeLike>
+ bool match( RangeLike&& rng ) const {
+ auto rng_start = begin( rng );
+ const auto rng_end = end( rng );
+ auto target_start = begin( m_desired );
+ const auto target_end = end( m_desired );
+
+ while (rng_start != rng_end && target_start != target_end) {
+ if (!m_predicate(*rng_start, *target_start)) {
+ return false;
+ }
+ ++rng_start;
+ ++target_start;
+ }
+ return rng_start == rng_end && target_start == target_end;
+ }
+
+ std::string describe() const override {
+ return "elements are " + Catch::Detail::stringify( m_desired );
+ }
+ };
+
+ /**
+ * Matcher for checking that an element contains the same
+ * elements (but not necessarily in the same order)
+ */
+ template <typename TargetRangeLike, typename Equality>
+ class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
+ TargetRangeLike m_desired;
+ Equality m_predicate;
+
+ public:
+ template <typename TargetRangeLike2, typename Equality2>
+ UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
+ Equality2&& predicate ):
+ m_desired( CATCH_FORWARD( range ) ),
+ m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+ template <typename RangeLike>
+ bool match( RangeLike&& rng ) const {
+ using std::begin;
+ using std::end;
+ return Catch::Detail::is_permutation( begin( m_desired ),
+ end( m_desired ),
+ begin( rng ),
+ end( rng ),
+ m_predicate );
+ }
+
+ std::string describe() const override {
+ return "unordered elements are " +
+ ::Catch::Detail::stringify( m_desired );
+ }
+ };
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range.
+ *
+ * Uses `std::equal_to` to do the comparison
+ */
+ template <typename RangeLike>
+ std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
+ RangeEqualsMatcher<RangeLike, std::equal_to<>>>
+ RangeEquals( RangeLike&& range ) {
+ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range.
+ *
+ * Uses to provided predicate `predicate` to do the comparisons
+ */
+ template <typename RangeLike, typename Equality>
+ RangeEqualsMatcher<RangeLike, Equality>
+ RangeEquals( RangeLike&& range, Equality&& predicate ) {
+ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range, in some permutation
+ *
+ * Uses `std::equal_to` to do the comparison
+ */
+ template <typename RangeLike>
+ std::enable_if_t<
+ !Detail::is_matcher<RangeLike>::value,
+ UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+ UnorderedRangeEquals( RangeLike&& range ) {
+ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range, in some permutation.
+ *
+ * Uses to provided predicate `predicate` to do the comparisons
+ */
+ template <typename RangeLike, typename Equality>
+ UnorderedRangeEqualsMatcher<RangeLike, Equality>
+ UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
+ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+ }
+ } // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_string.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers_string.cpp
index 2fc3a55638299dd7b3fca1c6c6f43bb39868de39..55002848b4cddf6fa64f605ead4372efb1775ef0 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_string.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_string.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_string.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_string.hpp
index 7f961c45ed5082f0fb6b89f80a21acafbbc04b7b..718022e31c831e183ceadb69ec17659e6ef452ed 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_string.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_string.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_templated.cpp b/packages/Catch2/src/catch2/matchers/catch_matchers_templated.cpp
index a336d8989666be29065e47fbfbab09e21fac8d9b..2fc529d2b90e9f52ea6c7432cae46880ea6c7ad8 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_templated.cpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_templated.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_templated.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_templated.hpp
index 8c7804ce91824f058b0cb6271319c2c4def86a1a..ba0661ae5caa9d833ec9cc4288028165301cf446 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_templated.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_templated.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,6 +11,7 @@
#include <catch2/matchers/catch_matchers.hpp>
#include <catch2/internal/catch_stringref.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
+#include <catch2/internal/catch_logical_traits.hpp>
#include <array>
#include <algorithm>
@@ -24,7 +25,7 @@ namespace Matchers {
MatcherGenericBase() = default;
~MatcherGenericBase() override; // = default;
- MatcherGenericBase(MatcherGenericBase&) = default;
+ MatcherGenericBase(MatcherGenericBase const&) = default;
MatcherGenericBase(MatcherGenericBase&&) = default;
MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
@@ -56,20 +57,6 @@ namespace Matchers {
return arr;
}
-#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
-
- using std::conjunction;
-
-#else // __cpp_lib_logical_traits
-
- template<typename... Cond>
- struct conjunction : std::true_type {};
-
- template<typename Cond, typename... Rest>
- struct conjunction<Cond, Rest...> : std::integral_constant<bool, Cond::value && conjunction<Rest...>::value> {};
-
-#endif // __cpp_lib_logical_traits
-
template<typename T>
using is_generic_matcher = std::is_base_of<
Catch::Matchers::MatcherGenericBase,
@@ -77,7 +64,7 @@ namespace Matchers {
>;
template<typename... Ts>
- using are_generic_matchers = conjunction<is_generic_matcher<Ts>...>;
+ using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
template<typename T>
using is_matcher = std::is_base_of<
diff --git a/packages/Catch2/src/catch2/matchers/catch_matchers_vector.hpp b/packages/Catch2/src/catch2/matchers/catch_matchers_vector.hpp
index b9a02f579cc5efeb334d83952d155d43d33f2a36..fffbfdf63c3bcb67cd25fc268f541a18d1d93a11 100644
--- a/packages/Catch2/src/catch2/matchers/catch_matchers_vector.hpp
+++ b/packages/Catch2/src/catch2/matchers/catch_matchers_vector.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -85,11 +85,10 @@ namespace Matchers {
// - a more general approach would be via a compare template that defaults
// to using !=. but could be specialised for, e.g. std::vector<T> etc
// - then just call that directly
- if (m_comparator.size() != v.size())
- return false;
- for (std::size_t i = 0; i < v.size(); ++i)
- if (m_comparator[i] != v[i])
- return false;
+ if ( m_comparator.size() != v.size() ) { return false; }
+ for ( std::size_t i = 0; i < v.size(); ++i ) {
+ if ( !( m_comparator[i] == v[i] ) ) { return false; }
+ }
return true;
}
std::string describe() const override {
diff --git a/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.cpp b/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.cpp
index 2c2a61179a243435b747efdb768e2a06aaf26aaf..41b462e515570ffde0ad55daeba978696b7d805e 100644
--- a/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.cpp
+++ b/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -16,9 +16,9 @@ namespace Catch {
// This is the general overload that takes a any string matcher
// There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
// the Equals matcher (so the header does not mention matchers)
- void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString ) {
+ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
std::string exceptionMessage = Catch::translateActiveException();
- MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher, matcherString );
+ MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
handler.handleExpr( expr );
}
diff --git a/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.hpp b/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.hpp
index 5d00ad7d54cee4054833408928a13fc4eddf1444..2ee9f0c0947b3bbda089213f68f68bc29efc7017 100644
--- a/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.hpp
+++ b/packages/Catch2/src/catch2/matchers/internal/catch_matchers_impl.hpp
@@ -1,30 +1,32 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
#define CATCH_MATCHERS_IMPL_HPP_INCLUDED
-#include <catch2/internal/catch_test_macro_impl.hpp>
-#include <catch2/internal/catch_stringref.hpp>
+#include <catch2/internal/catch_assertion_handler.hpp>
+#include <catch2/internal/catch_source_line_info.hpp>
+#include <catch2/internal/catch_decomposer.hpp>
+#include <catch2/internal/catch_preprocessor_internal_stringify.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
+#include <string>
+
namespace Catch {
template<typename ArgT, typename MatcherT>
class MatchExpr : public ITransientExpression {
ArgT && m_arg;
MatcherT const& m_matcher;
- StringRef m_matcherString;
public:
- MatchExpr( ArgT && arg, MatcherT const& matcher, StringRef matcherString )
+ MatchExpr( ArgT && arg, MatcherT const& matcher )
: ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
m_arg( CATCH_FORWARD(arg) ),
- m_matcher( matcher ),
- m_matcherString( matcherString )
+ m_matcher( matcher )
{}
void streamReconstructedExpression( std::ostream& os ) const override {
@@ -41,11 +43,11 @@ namespace Catch {
using StringMatcher = Matchers::MatcherBase<std::string>;
- void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString );
+ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
template<typename ArgT, typename MatcherT>
- auto makeMatchExpr( ArgT && arg, MatcherT const& matcher, StringRef matcherString ) -> MatchExpr<ArgT, MatcherT> {
- return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher, matcherString );
+ auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
+ return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
}
} // namespace Catch
@@ -56,7 +58,7 @@ namespace Catch {
do { \
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
INTERNAL_CATCH_TRY { \
- catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
+ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
} INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
INTERNAL_CATCH_REACT( catchAssertionHandler ) \
} while( false )
@@ -72,7 +74,7 @@ namespace Catch {
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
} \
catch( exceptionType const& ex ) { \
- catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
} \
catch( ... ) { \
catchAssertionHandler.handleUnexpectedInflightException(); \
diff --git a/packages/Catch2/src/catch2/meson.build b/packages/Catch2/src/catch2/meson.build
new file mode 100644
index 0000000000000000000000000000000000000000..2e9469d8419ed99e188ab5d4f233080ad5a0c9b1
--- /dev/null
+++ b/packages/Catch2/src/catch2/meson.build
@@ -0,0 +1,370 @@
+# Copyright Catch2 Authors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at
+# https://www.boost.org/LICENSE_1_0.txt)
+
+# SPDX-License-Identifier: BSL-1.0
+pkg = import('pkgconfig')
+
+conf_data = configuration_data()
+conf_data.set('CATCH_CONFIG_DEFAULT_REPORTER', 'console')
+conf_data.set('CATCH_CONFIG_CONSOLE_WIDTH', '80')
+
+configure_file(
+ input: 'catch_user_config.hpp.in',
+ output: 'catch_user_config.hpp',
+ format: 'cmake@',
+ install_dir: get_option('includedir') / 'catch2',
+ configuration: conf_data,
+)
+
+benchmark_headers = [
+ 'benchmark/catch_benchmark.hpp',
+ 'benchmark/catch_benchmark_all.hpp',
+ 'benchmark/catch_chronometer.hpp',
+ 'benchmark/catch_clock.hpp',
+ 'benchmark/catch_constructor.hpp',
+ 'benchmark/catch_environment.hpp',
+ 'benchmark/catch_estimate.hpp',
+ 'benchmark/catch_execution_plan.hpp',
+ 'benchmark/catch_optimizer.hpp',
+ 'benchmark/catch_outlier_classification.hpp',
+ 'benchmark/catch_sample_analysis.hpp',
+ 'benchmark/detail/catch_analyse.hpp',
+ 'benchmark/detail/catch_benchmark_function.hpp',
+ 'benchmark/detail/catch_benchmark_stats.hpp',
+ 'benchmark/detail/catch_benchmark_stats_fwd.hpp',
+ 'benchmark/detail/catch_complete_invoke.hpp',
+ 'benchmark/detail/catch_estimate_clock.hpp',
+ 'benchmark/detail/catch_measure.hpp',
+ 'benchmark/detail/catch_repeat.hpp',
+ 'benchmark/detail/catch_run_for_at_least.hpp',
+ 'benchmark/detail/catch_stats.hpp',
+ 'benchmark/detail/catch_timing.hpp',
+]
+
+benchmark_sources = files(
+ 'benchmark/catch_chronometer.cpp',
+ 'benchmark/detail/catch_benchmark_function.cpp',
+ 'benchmark/detail/catch_run_for_at_least.cpp',
+ 'benchmark/detail/catch_stats.cpp',
+)
+
+internal_headers = [
+ 'generators/catch_generator_exception.hpp',
+ 'generators/catch_generators.hpp',
+ 'generators/catch_generators_adapters.hpp',
+ 'generators/catch_generators_all.hpp',
+ 'generators/catch_generators_random.hpp',
+ 'generators/catch_generators_range.hpp',
+ 'interfaces/catch_interfaces_all.hpp',
+ 'interfaces/catch_interfaces_capture.hpp',
+ 'interfaces/catch_interfaces_config.hpp',
+ 'interfaces/catch_interfaces_enum_values_registry.hpp',
+ 'interfaces/catch_interfaces_exception.hpp',
+ 'interfaces/catch_interfaces_generatortracker.hpp',
+ 'interfaces/catch_interfaces_registry_hub.hpp',
+ 'interfaces/catch_interfaces_reporter.hpp',
+ 'interfaces/catch_interfaces_reporter_factory.hpp',
+ 'interfaces/catch_interfaces_tag_alias_registry.hpp',
+ 'interfaces/catch_interfaces_test_invoker.hpp',
+ 'interfaces/catch_interfaces_testcase.hpp',
+ 'internal/catch_assertion_handler.hpp',
+ 'internal/catch_case_insensitive_comparisons.hpp',
+ 'internal/catch_case_sensitive.hpp',
+ 'internal/catch_clara.hpp',
+ 'internal/catch_commandline.hpp',
+ 'internal/catch_compare_traits.hpp',
+ 'internal/catch_compiler_capabilities.hpp',
+ 'internal/catch_config_android_logwrite.hpp',
+ 'internal/catch_config_counter.hpp',
+ 'internal/catch_config_static_analysis_support.hpp',
+ 'internal/catch_config_uncaught_exceptions.hpp',
+ 'internal/catch_config_wchar.hpp',
+ 'internal/catch_console_colour.hpp',
+ 'internal/catch_console_width.hpp',
+ 'internal/catch_container_nonmembers.hpp',
+ 'internal/catch_context.hpp',
+ 'internal/catch_debug_console.hpp',
+ 'internal/catch_debugger.hpp',
+ 'internal/catch_decomposer.hpp',
+ 'internal/catch_enforce.hpp',
+ 'internal/catch_enum_values_registry.hpp',
+ 'internal/catch_errno_guard.hpp',
+ 'internal/catch_exception_translator_registry.hpp',
+ 'internal/catch_fatal_condition_handler.hpp',
+ 'internal/catch_floating_point_helpers.hpp',
+ 'internal/catch_getenv.hpp',
+ 'internal/catch_istream.hpp',
+ 'internal/catch_is_permutation.hpp',
+ 'internal/catch_lazy_expr.hpp',
+ 'internal/catch_leak_detector.hpp',
+ 'internal/catch_list.hpp',
+ 'internal/catch_logical_traits.hpp',
+ 'internal/catch_message_info.hpp',
+ 'internal/catch_meta.hpp',
+ 'internal/catch_move_and_forward.hpp',
+ 'internal/catch_noncopyable.hpp',
+ 'internal/catch_optional.hpp',
+ 'internal/catch_output_redirect.hpp',
+ 'internal/catch_parse_numbers.hpp',
+ 'internal/catch_platform.hpp',
+ 'internal/catch_polyfills.hpp',
+ 'internal/catch_preprocessor.hpp',
+ 'internal/catch_preprocessor_internal_stringify.hpp',
+ 'internal/catch_preprocessor_remove_parens.hpp',
+ 'internal/catch_random_number_generator.hpp',
+ 'internal/catch_random_seed_generation.hpp',
+ 'internal/catch_reporter_registry.hpp',
+ 'internal/catch_reporter_spec_parser.hpp',
+ 'internal/catch_result_type.hpp',
+ 'internal/catch_reusable_string_stream.hpp',
+ 'internal/catch_run_context.hpp',
+ 'internal/catch_section.hpp',
+ 'internal/catch_sharding.hpp',
+ 'internal/catch_singletons.hpp',
+ 'internal/catch_source_line_info.hpp',
+ 'internal/catch_startup_exception_registry.hpp',
+ 'internal/catch_stdstreams.hpp',
+ 'internal/catch_stream_end_stop.hpp',
+ 'internal/catch_string_manip.hpp',
+ 'internal/catch_stringref.hpp',
+ 'internal/catch_tag_alias_registry.hpp',
+ 'internal/catch_template_test_registry.hpp',
+ 'internal/catch_test_case_info_hasher.hpp',
+ 'internal/catch_test_case_registry_impl.hpp',
+ 'internal/catch_test_case_tracker.hpp',
+ 'internal/catch_test_failure_exception.hpp',
+ 'internal/catch_test_macro_impl.hpp',
+ 'internal/catch_test_registry.hpp',
+ 'internal/catch_test_run_info.hpp',
+ 'internal/catch_test_spec_parser.hpp',
+ 'internal/catch_textflow.hpp',
+ 'internal/catch_to_string.hpp',
+ 'internal/catch_uncaught_exceptions.hpp',
+ 'internal/catch_unique_name.hpp',
+ 'internal/catch_unique_ptr.hpp',
+ 'internal/catch_void_type.hpp',
+ 'internal/catch_wildcard_pattern.hpp',
+ 'internal/catch_windows_h_proxy.hpp',
+ 'internal/catch_xmlwriter.hpp',
+ 'matchers/catch_matchers.hpp',
+ 'matchers/catch_matchers_all.hpp',
+ 'matchers/catch_matchers_container_properties.hpp',
+ 'matchers/catch_matchers_contains.hpp',
+ 'matchers/catch_matchers_exception.hpp',
+ 'matchers/catch_matchers_floating_point.hpp',
+ 'matchers/catch_matchers_predicate.hpp',
+ 'matchers/catch_matchers_quantifiers.hpp',
+ 'matchers/catch_matchers_string.hpp',
+ 'matchers/catch_matchers_templated.hpp',
+ 'matchers/catch_matchers_vector.hpp',
+ 'matchers/internal/catch_matchers_impl.hpp',
+ 'catch_all.hpp',
+ 'catch_approx.hpp',
+ 'catch_assertion_info.hpp',
+ 'catch_assertion_result.hpp',
+ 'catch_config.hpp',
+ 'catch_get_random_seed.hpp',
+ 'catch_message.hpp',
+ 'catch_section_info.hpp',
+ 'catch_session.hpp',
+ 'catch_tag_alias.hpp',
+ 'catch_tag_alias_autoregistrar.hpp',
+ 'catch_template_test_macros.hpp',
+ 'catch_test_case_info.hpp',
+ 'catch_test_macros.hpp',
+ 'catch_test_spec.hpp',
+ 'catch_timer.hpp',
+ 'catch_tostring.hpp',
+ 'catch_totals.hpp',
+ 'catch_translate_exception.hpp',
+ 'catch_version.hpp',
+ 'catch_version_macros.hpp',
+]
+
+internal_sources = files(
+ 'generators/catch_generator_exception.cpp',
+ 'generators/catch_generators.cpp',
+ 'generators/catch_generators_random.cpp',
+ 'interfaces/catch_interfaces_capture.cpp',
+ 'interfaces/catch_interfaces_config.cpp',
+ 'interfaces/catch_interfaces_exception.cpp',
+ 'interfaces/catch_interfaces_generatortracker.cpp',
+ 'interfaces/catch_interfaces_registry_hub.cpp',
+ 'interfaces/catch_interfaces_reporter.cpp',
+ 'interfaces/catch_interfaces_reporter_factory.cpp',
+ 'interfaces/catch_interfaces_testcase.cpp',
+ 'internal/catch_assertion_handler.cpp',
+ 'internal/catch_case_insensitive_comparisons.cpp',
+ 'internal/catch_clara.cpp',
+ 'internal/catch_commandline.cpp',
+ 'internal/catch_console_colour.cpp',
+ 'internal/catch_context.cpp',
+ 'internal/catch_debug_console.cpp',
+ 'internal/catch_debugger.cpp',
+ 'internal/catch_decomposer.cpp',
+ 'internal/catch_enforce.cpp',
+ 'internal/catch_enum_values_registry.cpp',
+ 'internal/catch_errno_guard.cpp',
+ 'internal/catch_exception_translator_registry.cpp',
+ 'internal/catch_fatal_condition_handler.cpp',
+ 'internal/catch_floating_point_helpers.cpp',
+ 'internal/catch_getenv.cpp',
+ 'internal/catch_istream.cpp',
+ 'internal/catch_lazy_expr.cpp',
+ 'internal/catch_leak_detector.cpp',
+ 'internal/catch_list.cpp',
+ 'internal/catch_message_info.cpp',
+ 'internal/catch_output_redirect.cpp',
+ 'internal/catch_parse_numbers.cpp',
+ 'internal/catch_polyfills.cpp',
+ 'internal/catch_random_number_generator.cpp',
+ 'internal/catch_random_seed_generation.cpp',
+ 'internal/catch_reporter_registry.cpp',
+ 'internal/catch_reporter_spec_parser.cpp',
+ 'internal/catch_result_type.cpp',
+ 'internal/catch_reusable_string_stream.cpp',
+ 'internal/catch_run_context.cpp',
+ 'internal/catch_section.cpp',
+ 'internal/catch_singletons.cpp',
+ 'internal/catch_source_line_info.cpp',
+ 'internal/catch_startup_exception_registry.cpp',
+ 'internal/catch_stdstreams.cpp',
+ 'internal/catch_string_manip.cpp',
+ 'internal/catch_stringref.cpp',
+ 'internal/catch_tag_alias_registry.cpp',
+ 'internal/catch_test_case_info_hasher.cpp',
+ 'internal/catch_test_case_registry_impl.cpp',
+ 'internal/catch_test_case_tracker.cpp',
+ 'internal/catch_test_failure_exception.cpp',
+ 'internal/catch_test_registry.cpp',
+ 'internal/catch_test_spec_parser.cpp',
+ 'internal/catch_textflow.cpp',
+ 'internal/catch_uncaught_exceptions.cpp',
+ 'internal/catch_wildcard_pattern.cpp',
+ 'internal/catch_xmlwriter.cpp',
+ 'matchers/catch_matchers.cpp',
+ 'matchers/catch_matchers_container_properties.cpp',
+ 'matchers/catch_matchers_exception.cpp',
+ 'matchers/catch_matchers_floating_point.cpp',
+ 'matchers/catch_matchers_predicate.cpp',
+ 'matchers/catch_matchers_quantifiers.cpp',
+ 'matchers/catch_matchers_string.cpp',
+ 'matchers/catch_matchers_templated.cpp',
+ 'matchers/internal/catch_matchers_impl.cpp',
+ 'catch_approx.cpp',
+ 'catch_assertion_result.cpp',
+ 'catch_config.cpp',
+ 'catch_get_random_seed.cpp',
+ 'catch_message.cpp',
+ 'catch_registry_hub.cpp',
+ 'catch_session.cpp',
+ 'catch_tag_alias_autoregistrar.cpp',
+ 'catch_test_case_info.cpp',
+ 'catch_test_spec.cpp',
+ 'catch_timer.cpp',
+ 'catch_tostring.cpp',
+ 'catch_totals.cpp',
+ 'catch_translate_exception.cpp',
+ 'catch_version.cpp',
+)
+
+reporter_headers = [
+ 'reporters/catch_reporter_automake.hpp',
+ 'reporters/catch_reporter_common_base.hpp',
+ 'reporters/catch_reporter_compact.hpp',
+ 'reporters/catch_reporter_console.hpp',
+ 'reporters/catch_reporter_cumulative_base.hpp',
+ 'reporters/catch_reporter_event_listener.hpp',
+ 'reporters/catch_reporter_helpers.hpp',
+ 'reporters/catch_reporter_junit.hpp',
+ 'reporters/catch_reporter_multi.hpp',
+ 'reporters/catch_reporter_registrars.hpp',
+ 'reporters/catch_reporter_sonarqube.hpp',
+ 'reporters/catch_reporter_streaming_base.hpp',
+ 'reporters/catch_reporter_tap.hpp',
+ 'reporters/catch_reporter_teamcity.hpp',
+ 'reporters/catch_reporter_xml.hpp',
+ 'reporters/catch_reporters_all.hpp',
+]
+
+reporter_sources = files(
+ 'reporters/catch_reporter_automake.cpp',
+ 'reporters/catch_reporter_common_base.cpp',
+ 'reporters/catch_reporter_compact.cpp',
+ 'reporters/catch_reporter_console.cpp',
+ 'reporters/catch_reporter_cumulative_base.cpp',
+ 'reporters/catch_reporter_event_listener.cpp',
+ 'reporters/catch_reporter_helpers.cpp',
+ 'reporters/catch_reporter_junit.cpp',
+ 'reporters/catch_reporter_multi.cpp',
+ 'reporters/catch_reporter_registrars.cpp',
+ 'reporters/catch_reporter_sonarqube.cpp',
+ 'reporters/catch_reporter_streaming_base.cpp',
+ 'reporters/catch_reporter_tap.cpp',
+ 'reporters/catch_reporter_teamcity.cpp',
+ 'reporters/catch_reporter_xml.cpp',
+)
+
+headers = benchmark_headers + internal_headers + reporter_headers
+sources = benchmark_sources + internal_sources + reporter_sources
+
+# The headers must be installed with their full paths, which meson
+# v0.63 supports using `preserve_path` for `install_headers`. We'd
+# like to be compatible with Debian 11 (current stable) which has
+# meson v0.56.2. Instead, let's use the technique from
+# https://github.com/mesonbuild/meson/issues/14 with some tweaks to
+# make it compatible with newer meson.
+include_subdir = 'catch2'
+foreach file : headers
+ file_path = file.split('/')
+
+ folder = ''
+ foreach path : file_path
+ if path != file_path[-1]
+ folder = folder / path
+ endif
+ endforeach
+
+ install_headers(file, subdir: join_paths(include_subdir, folder))
+endforeach
+
+catch2 = static_library(
+ 'Catch2',
+ sources,
+ include_directories: '..',
+ install: true,
+)
+
+catch2_dep = declare_dependency(
+ link_with: catch2,
+ include_directories: '..',
+)
+
+pkg.generate(
+ catch2,
+ filebase: 'catch2',
+ description: 'A modern, C++-native, test framework for C++14 and above',
+ url: 'https://github.com/catchorg/Catch2',
+)
+
+catch2_with_main = static_library(
+ 'Catch2Main',
+ 'internal/catch_main.cpp',
+ link_with: catch2,
+ include_directories: '..',
+ install: true,
+)
+
+catch2_with_main_dep = declare_dependency(
+ link_with: [catch2, catch2_with_main],
+ include_directories: '..',
+)
+
+pkg.generate(
+ catch2_with_main,
+ filebase: 'catch2-with-main',
+ description: 'A modern, C++-native, test framework for C++14 and above (links in default main)',
+ requires: 'catch2 = ' + meson.project_version(),
+)
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_automake.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_automake.cpp
index 90b12928df803ca3a32eab69d36280f8d3b17294..993b594b8566206c998a4c2c471d7218d9662bd3 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_automake.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_automake.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -17,7 +17,9 @@ namespace Catch {
void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
// Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
m_stream << ":test-result: ";
- if (_testCaseStats.totals.assertions.allPassed()) {
+ if ( _testCaseStats.totals.testCases.skipped > 0 ) {
+ m_stream << "SKIP";
+ } else if (_testCaseStats.totals.assertions.allPassed()) {
m_stream << "PASS";
} else if (_testCaseStats.totals.assertions.allOk()) {
m_stream << "XFAIL";
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_automake.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_automake.hpp
index bf18fddf7d0b82eb3137b5852827c08fcfe987bd..a639428c336695e8bbc2af69013887e898c70dc8 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_automake.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_automake.hpp
@@ -1,14 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/reporters/catch_reporter_streaming_base.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.cpp
index 698435d044c4093880034347c100b3ba43cf0f61..a1ca76a0f8aaa0a32c6125009b46b4dc4de766ce 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.hpp
index e6888be1664ff83ce2926e9abb2078fe23516465..b4f0a9ff55c444d39ebcb3196772d3416ab6c371 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_common_base.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_compact.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_compact.cpp
index a09f0483d53e690be0b764f7461f45d8fa823b11..88acb6a465ac8864e6691d96d5e384899a0481b7 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_compact.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_compact.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -18,22 +18,6 @@
#include <ostream>
-namespace {
-
- constexpr Catch::StringRef bothOrAll( std::uint64_t count ) {
- switch (count) {
- case 1:
- return Catch::StringRef{};
- case 2:
- return "both "_catch_sr;
- default:
- return "all "_catch_sr;
- }
- }
-
-} // anon namespace
-
-
namespace Catch {
namespace {
@@ -48,42 +32,6 @@ namespace {
static constexpr Catch::StringRef compactPassedString = "passed"_sr;
#endif
-// Colour, message variants:
-// - white: No tests ran.
-// - red: Failed [both/all] N test cases, failed [both/all] M assertions.
-// - white: Passed [both/all] N test cases (no assertions).
-// - red: Failed N tests cases, failed M assertions.
-// - green: Passed [both/all] N tests cases with M assertions.
-void printTotals(std::ostream& out, const Totals& totals, ColourImpl* colourImpl) {
- if (totals.testCases.total() == 0) {
- out << "No tests ran.";
- } else if (totals.testCases.failed == totals.testCases.total()) {
- auto guard = colourImpl->guardColour( Colour::ResultError ).engage( out );
- const StringRef qualify_assertions_failed =
- totals.assertions.failed == totals.assertions.total() ?
- bothOrAll(totals.assertions.failed) : StringRef{};
- out <<
- "Failed " << bothOrAll(totals.testCases.failed)
- << pluralise(totals.testCases.failed, "test case"_sr) << ", "
- "failed " << qualify_assertions_failed <<
- pluralise(totals.assertions.failed, "assertion"_sr) << '.';
- } else if (totals.assertions.total() == 0) {
- out <<
- "Passed " << bothOrAll(totals.testCases.total())
- << pluralise(totals.testCases.total(), "test case"_sr)
- << " (no assertions).";
- } else if (totals.assertions.failed) {
- out << colourImpl->guardColour( Colour::ResultError ) <<
- "Failed " << pluralise(totals.testCases.failed, "test case"_sr) << ", "
- "failed " << pluralise(totals.assertions.failed, "assertion"_sr) << '.';
- } else {
- out << colourImpl->guardColour( Colour::ResultSuccess ) <<
- "Passed " << bothOrAll(totals.testCases.passed)
- << pluralise(totals.testCases.passed, "test case"_sr) <<
- " with " << pluralise(totals.assertions.passed, "assertion"_sr) << '.';
- }
-}
-
// Implementation of CompactReporter formatting
class AssertionPrinter {
public:
@@ -157,6 +105,11 @@ public:
printIssue("explicitly");
printRemainingMessages(Colour::None);
break;
+ case ResultWas::ExplicitSkip:
+ printResultType(Colour::Skip, "skipped"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
@@ -218,7 +171,7 @@ private:
return;
const auto itEnd = messages.cend();
- const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+ const auto N = static_cast<std::size_t>(itEnd - itMessage);
stream << colourImpl->guardColour( colour ) << " with "
<< pluralise( N, "message"_sr ) << ':';
@@ -239,7 +192,7 @@ private:
private:
std::ostream& stream;
AssertionResult const& result;
- std::vector<MessageInfo> messages;
+ std::vector<MessageInfo> const& messages;
std::vector<MessageInfo>::const_iterator itMessage;
bool printInfoMessages;
ColourImpl* colourImpl;
@@ -259,7 +212,7 @@ private:
if ( m_config->testSpec().hasFilters() ) {
m_stream << m_colour->guardColour( Colour::BrightYellow )
<< "Filters: "
- << serializeFilters( m_config->getTestsOrTags() )
+ << m_config->testSpec()
<< '\n';
}
m_stream << "RNG seed: " << getSeed() << '\n';
@@ -272,7 +225,7 @@ private:
// Drop out if result was successful and we're not printing those
if( !m_config->includeSuccessfulResults() && result.isOk() ) {
- if( result.getResultType() != ResultWas::Warning )
+ if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
return;
printInfoMessages = false;
}
@@ -291,7 +244,7 @@ private:
}
void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
- printTotals( m_stream, _testRunStats.totals, m_colour.get() );
+ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
m_stream << "\n\n" << std::flush;
StreamingReporterBase::testRunEnded( _testRunStats );
}
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_compact.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_compact.hpp
index 6362fc2977ca2f2d3a276c24000afabc3d26232b..d95bbff11978585e26d9f464a015daed9728a505 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_compact.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_compact.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_console.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_console.cpp
index 88d43b531fd4ca84c10b275780a5159257214127..a46b22cf086c3fad78a002ab72f8232b2156855b 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_console.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_console.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -51,7 +51,6 @@ public:
stats(_stats),
result(_stats.assertionResult),
colour(Colour::None),
- message(result.getMessage()),
messages(_stats.infoMessages),
colourImpl(colourImpl_),
printInfoMessages(_printInfoMessages) {
@@ -60,10 +59,10 @@ public:
colour = Colour::Success;
passOrFail = "PASSED"_sr;
//if( result.hasMessage() )
- if (_stats.infoMessages.size() == 1)
- messageLabel = "with message";
- if (_stats.infoMessages.size() > 1)
- messageLabel = "with messages";
+ if (messages.size() == 1)
+ messageLabel = "with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "with messages"_sr;
break;
case ResultWas::ExpressionFailed:
if (result.isOk()) {
@@ -73,43 +72,57 @@ public:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
}
- if (_stats.infoMessages.size() == 1)
- messageLabel = "with message";
- if (_stats.infoMessages.size() > 1)
- messageLabel = "with messages";
+ if (messages.size() == 1)
+ messageLabel = "with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "with messages"_sr;
break;
case ResultWas::ThrewException:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
- messageLabel = "due to unexpected exception with ";
- if (_stats.infoMessages.size() == 1)
- messageLabel += "message";
- if (_stats.infoMessages.size() > 1)
- messageLabel += "messages";
+ // todo switch
+ switch (messages.size()) { case 0:
+ messageLabel = "due to unexpected exception with "_sr;
+ break;
+ case 1:
+ messageLabel = "due to unexpected exception with message"_sr;
+ break;
+ default:
+ messageLabel = "due to unexpected exception with messages"_sr;
+ break;
+ }
break;
case ResultWas::FatalErrorCondition:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
- messageLabel = "due to a fatal error condition";
+ messageLabel = "due to a fatal error condition"_sr;
break;
case ResultWas::DidntThrowException:
colour = Colour::Error;
passOrFail = "FAILED"_sr;
- messageLabel = "because no exception was thrown where one was expected";
+ messageLabel = "because no exception was thrown where one was expected"_sr;
break;
case ResultWas::Info:
- messageLabel = "info";
+ messageLabel = "info"_sr;
break;
case ResultWas::Warning:
- messageLabel = "warning";
+ messageLabel = "warning"_sr;
break;
case ResultWas::ExplicitFailure:
passOrFail = "FAILED"_sr;
colour = Colour::Error;
- if (_stats.infoMessages.size() == 1)
- messageLabel = "explicitly with message";
- if (_stats.infoMessages.size() > 1)
- messageLabel = "explicitly with messages";
+ if (messages.size() == 1)
+ messageLabel = "explicitly with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "explicitly with messages"_sr;
+ break;
+ case ResultWas::ExplicitSkip:
+ colour = Colour::Skip;
+ passOrFail = "SKIPPED"_sr;
+ if (messages.size() == 1)
+ messageLabel = "explicitly with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "explicitly with messages"_sr;
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
@@ -173,9 +186,8 @@ private:
AssertionResult const& result;
Colour::Code colour;
StringRef passOrFail;
- std::string messageLabel;
- std::string message;
- std::vector<MessageInfo> messages;
+ StringRef messageLabel;
+ std::vector<MessageInfo> const& messages;
ColourImpl* colourImpl;
bool printInfoMessages;
};
@@ -185,13 +197,16 @@ std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
}
-std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
- if (i > j && i > k)
+std::size_t&
+findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
+ if (i > j && i > k && i > l)
return i;
- else if (j > k)
+ else if (j > k && j > l)
return j;
- else
+ else if (k > l)
return k;
+ else
+ return l;
}
enum class Justification { Left, Right };
@@ -400,7 +415,8 @@ void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
// Drop out if result was successful but we're not printing them.
- if (!includeResults && result.getResultType() != ResultWas::Warning)
+ // TODO: Make configurable whether skips should be printed
+ if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
return;
lazyPrint();
@@ -491,7 +507,7 @@ void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
}
void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
printTotalsDivider(_testRunStats.totals);
- printTotals(_testRunStats.totals);
+ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
m_stream << '\n' << std::flush;
StreamingReporterBase::testRunEnded(_testRunStats);
}
@@ -499,7 +515,7 @@ void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
StreamingReporterBase::testRunStarting(_testInfo);
if ( m_config->testSpec().hasFilters() ) {
m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
- << serializeFilters( m_config->getTestsOrTags() ) << '\n';
+ << m_config->testSpec() << '\n';
}
m_stream << "Randomness seeded to: " << getSeed() << '\n';
}
@@ -598,91 +614,16 @@ void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t
<< '\n';
}
-struct SummaryColumn {
-
- SummaryColumn( std::string _label, Colour::Code _colour )
- : label( CATCH_MOVE( _label ) ),
- colour( _colour ) {}
- SummaryColumn addRow( std::uint64_t count ) {
- ReusableStringStream rss;
- rss << count;
- std::string row = rss.str();
- for (auto& oldRow : rows) {
- while (oldRow.size() < row.size())
- oldRow = ' ' + oldRow;
- while (oldRow.size() > row.size())
- row = ' ' + row;
- }
- rows.push_back(row);
- return *this;
- }
-
- std::string label;
- Colour::Code colour;
- std::vector<std::string> rows;
-
-};
-
-void ConsoleReporter::printTotals( Totals const& totals ) {
- if (totals.testCases.total() == 0) {
- m_stream << m_colour->guardColour( Colour::Warning )
- << "No tests ran\n";
- } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
- m_stream << m_colour->guardColour( Colour::ResultSuccess )
- << "All tests passed";
- m_stream << " ("
- << pluralise(totals.assertions.passed, "assertion"_sr) << " in "
- << pluralise(totals.testCases.passed, "test case"_sr) << ')'
- << '\n';
- } else {
-
- std::vector<SummaryColumn> columns;
- columns.push_back(SummaryColumn("", Colour::None)
- .addRow(totals.testCases.total())
- .addRow(totals.assertions.total()));
- columns.push_back(SummaryColumn("passed", Colour::Success)
- .addRow(totals.testCases.passed)
- .addRow(totals.assertions.passed));
- columns.push_back(SummaryColumn("failed", Colour::ResultError)
- .addRow(totals.testCases.failed)
- .addRow(totals.assertions.failed));
- columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
- .addRow(totals.testCases.failedButOk)
- .addRow(totals.assertions.failedButOk));
-
- printSummaryRow("test cases"_sr, columns, 0);
- printSummaryRow("assertions"_sr, columns, 1);
- }
-}
-void ConsoleReporter::printSummaryRow(StringRef label, std::vector<SummaryColumn> const& cols, std::size_t row) {
- for (auto col : cols) {
- std::string const& value = col.rows[row];
- if (col.label.empty()) {
- m_stream << label << ": ";
- if ( value != "0" ) {
- m_stream << value;
- } else {
- m_stream << m_colour->guardColour( Colour::Warning )
- << "- none -";
- }
- } else if (value != "0") {
- m_stream << m_colour->guardColour( Colour::LightGrey ) << " | "
- << m_colour->guardColour( col.colour ) << value << ' '
- << col.label;
- }
- }
- m_stream << '\n';
-}
-
void ConsoleReporter::printTotalsDivider(Totals const& totals) {
if (totals.testCases.total() > 0) {
std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
- while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
- findMax(failedRatio, failedButOkRatio, passedRatio)++;
+ std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
+ while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
- findMax(failedRatio, failedButOkRatio, passedRatio)--;
+ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
m_stream << m_colour->guardColour( Colour::Error )
<< std::string( failedRatio, '=' )
@@ -695,15 +636,14 @@ void ConsoleReporter::printTotalsDivider(Totals const& totals) {
m_stream << m_colour->guardColour( Colour::Success )
<< std::string( passedRatio, '=' );
}
+ m_stream << m_colour->guardColour( Colour::Skip )
+ << std::string( skippedRatio, '=' );
} else {
m_stream << m_colour->guardColour( Colour::Warning )
<< std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
}
m_stream << '\n';
}
-void ConsoleReporter::printSummaryDivider() {
- m_stream << lineOfChars('-') << '\n';
-}
} // end namespace Catch
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_console.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_console.hpp
index 719dcc449f73e6aea7d66a9d3928055529509129..243772622bdf3b4a6fc0cc29e4c490353646da76 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_console.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_console.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,7 +13,6 @@
namespace Catch {
// Fwd decls
- struct SummaryColumn;
class TablePrinter;
class ConsoleReporter final : public StreamingReporterBase {
@@ -57,12 +56,7 @@ namespace Catch {
// subsequent lines
void printHeaderString(std::string const& _string, std::size_t indent = 0);
-
- void printTotals(Totals const& totals);
- void printSummaryRow(StringRef label, std::vector<SummaryColumn> const& cols, std::size_t row);
-
void printTotalsDivider(Totals const& totals);
- void printSummaryDivider();
bool m_headerPrinted = false;
bool m_testRunInfoPrinted = false;
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.cpp
index 957880d09ddfd548007f2f6fa8d47de469fe3255..5e10632621472fc3b45f00574cef86625144c09c 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -70,7 +70,8 @@ namespace Catch {
void
CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
- SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+ // We need a copy, because SectionStats expect to take ownership
+ SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
SectionNode* node;
if ( m_sectionStack.empty() ) {
if ( !m_rootSection ) {
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.hpp
index c4dcdae0365c0b06dfa2205c642c76efee727f17..267b39fdbf171109a72304e7be95ac20b38ec6fc 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_cumulative_base.hpp
@@ -1,14 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/reporters/catch_reporter_common_base.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
#include <catch2/internal/catch_unique_ptr.hpp>
@@ -125,7 +124,7 @@ namespace Catch {
void skipTest(TestCaseInfo const&) override {}
protected:
- //! Should the cumulative base store the assertion expansion for succesful assertions?
+ //! Should the cumulative base store the assertion expansion for successful assertions?
bool m_shouldStoreSuccesfulAssertions = true;
//! Should the cumulative base store the assertion expansion for failed assertions?
bool m_shouldStoreFailedAssertions = true;
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.cpp
index a997a315d667aac202e3f0f124938f153023f318..e94063bafb23b5985be756ac9fced5b0ef57e350 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.hpp
index 3a6d822cc3432e2a2f9eaec68b98107fdc7b70ab..346263e21412c5c0fb62fe418a3ea7f1662c42b9 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_event_listener.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.cpp
index 31df851a834b64ec6916dfebe043057f1bfc3588..ffb32ffb0bb9f65134dda525f23c8fce014c1fe9 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -235,4 +235,109 @@ namespace Catch {
out << "\n\n" << std::flush;
}
+ namespace {
+ class SummaryColumn {
+ public:
+ SummaryColumn( std::string suffix, Colour::Code colour ):
+ m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
+
+ SummaryColumn&& addRow( std::uint64_t count ) && {
+ std::string row = std::to_string(count);
+ auto const new_width = std::max( m_width, row.size() );
+ if ( new_width > m_width ) {
+ for ( auto& oldRow : m_rows ) {
+ oldRow.insert( 0, new_width - m_width, ' ' );
+ }
+ } else {
+ row.insert( 0, m_width - row.size(), ' ' );
+ }
+ m_width = new_width;
+ m_rows.push_back( row );
+ return std::move( *this );
+ }
+
+ std::string const& getSuffix() const { return m_suffix; }
+ Colour::Code getColour() const { return m_colour; }
+ std::string const& getRow( std::size_t index ) const {
+ return m_rows[index];
+ }
+
+ private:
+ std::string m_suffix;
+ Colour::Code m_colour;
+ std::size_t m_width = 0;
+ std::vector<std::string> m_rows;
+ };
+
+ void printSummaryRow( std::ostream& stream,
+ ColourImpl& colour,
+ StringRef label,
+ std::vector<SummaryColumn> const& cols,
+ std::size_t row ) {
+ for ( auto const& col : cols ) {
+ auto const& value = col.getRow( row );
+ auto const& suffix = col.getSuffix();
+ if ( suffix.empty() ) {
+ stream << label << ": ";
+ if ( value != "0" ) {
+ stream << value;
+ } else {
+ stream << colour.guardColour( Colour::Warning )
+ << "- none -";
+ }
+ } else if ( value != "0" ) {
+ stream << colour.guardColour( Colour::LightGrey ) << " | "
+ << colour.guardColour( col.getColour() ) << value
+ << ' ' << suffix;
+ }
+ }
+ stream << '\n';
+ }
+ } // namespace
+
+ void printTestRunTotals( std::ostream& stream,
+ ColourImpl& streamColour,
+ Totals const& totals ) {
+ if ( totals.testCases.total() == 0 ) {
+ stream << streamColour.guardColour( Colour::Warning )
+ << "No tests ran\n";
+ return;
+ }
+
+ if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
+ stream << streamColour.guardColour( Colour::ResultSuccess )
+ << "All tests passed";
+ stream << " ("
+ << pluralise( totals.assertions.passed, "assertion"_sr )
+ << " in "
+ << pluralise( totals.testCases.passed, "test case"_sr )
+ << ')' << '\n';
+ return;
+ }
+
+ std::vector<SummaryColumn> columns;
+ // Don't include "skipped assertions" in total count
+ const auto totalAssertionCount =
+ totals.assertions.total() - totals.assertions.skipped;
+ columns.push_back( SummaryColumn( "", Colour::None )
+ .addRow( totals.testCases.total() )
+ .addRow( totalAssertionCount ) );
+ columns.push_back( SummaryColumn( "passed", Colour::Success )
+ .addRow( totals.testCases.passed )
+ .addRow( totals.assertions.passed ) );
+ columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+ .addRow( totals.testCases.failed )
+ .addRow( totals.assertions.failed ) );
+ columns.push_back( SummaryColumn( "skipped", Colour::Skip )
+ .addRow( totals.testCases.skipped )
+ // Don't print "skipped assertions"
+ .addRow( 0 ) );
+ columns.push_back(
+ SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+ .addRow( totals.testCases.failedButOk )
+ .addRow( totals.assertions.failedButOk ) );
+ printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
+ printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
+ }
+
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.hpp
index ef43534cba82150c28ce7f073c9f338f6138f134..316cb4048a16861e8c5e2b7de3375cdffb1d4df8 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_helpers.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -14,6 +14,7 @@
#include <catch2/internal/catch_list.hpp>
#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/catch_totals.hpp>
namespace Catch {
@@ -80,6 +81,15 @@ namespace Catch {
bool isFiltered,
Verbosity verbosity );
+ /**
+ * Prints test run totals to the provided stream in user-friendly format
+ *
+ * Used by the console and compact reporters.
+ */
+ void printTestRunTotals( std::ostream& stream,
+ ColourImpl& streamColour,
+ Totals const& totals );
+
} // end namespace Catch
#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_junit.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_junit.cpp
index c24d1efa253d3226fab22393814bd31a36658367..fc5cae34ad3629da116ddcbb71611f0305543520 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_junit.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_junit.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -13,6 +13,7 @@
#include <catch2/internal/catch_textflow.hpp>
#include <catch2/interfaces/catch_interfaces_config.hpp>
#include <catch2/catch_test_case_info.hpp>
+#include <catch2/catch_test_spec.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
#include <cassert>
@@ -30,6 +31,10 @@ namespace Catch {
std::tm timeInfo = {};
#if defined (_MSC_VER) || defined (__MINGW32__)
gmtime_s(&timeInfo, &rawtime);
+#elif defined (CATCH_PLATFORM_PLAYSTATION)
+ gmtime_s(&rawtime, &timeInfo);
+#elif defined (__IAR_SYSTEMS_ICC__)
+ timeInfo = *std::gmtime(&rawtime);
#else
gmtime_r(&rawtime, &timeInfo);
#endif
@@ -129,6 +134,7 @@ namespace Catch {
xml.writeAttribute( "name"_sr, stats.runInfo.name );
xml.writeAttribute( "errors"_sr, unexpectedExceptions );
xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
+ xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
if( m_config->showDurations() == ShowDurations::Never )
@@ -143,10 +149,10 @@ namespace Catch {
xml.scopedElement("property")
.writeAttribute("name"_sr, "random-seed"_sr)
.writeAttribute("value"_sr, m_config->rngSeed());
- if (m_config->hasTestFilters()) {
+ if (m_config->testSpec().hasFilters()) {
xml.scopedElement("property")
.writeAttribute("name"_sr, "filters"_sr)
- .writeAttribute("value"_sr, serializeFilters(m_config->getTestsOrTags()));
+ .writeAttribute("value"_sr, m_config->testSpec());
}
}
@@ -241,7 +247,8 @@ namespace Catch {
void JunitReporter::writeAssertion( AssertionStats const& stats ) {
AssertionResult const& result = stats.assertionResult;
- if( !result.isOk() ) {
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
std::string elementName;
switch( result.getResultType() ) {
case ResultWas::ThrewException:
@@ -253,7 +260,9 @@ namespace Catch {
case ResultWas::DidntThrowException:
elementName = "failure";
break;
-
+ case ResultWas::ExplicitSkip:
+ elementName = "skipped";
+ break;
// We should never see these here:
case ResultWas::Info:
case ResultWas::Warning:
@@ -271,7 +280,9 @@ namespace Catch {
xml.writeAttribute( "type"_sr, result.getTestMacroName() );
ReusableStringStream rss;
- if (stats.totals.assertions.total() > 0) {
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ rss << "SKIPPED\n";
+ } else {
rss << "FAILED" << ":\n";
if (result.hasExpression()) {
rss << " ";
@@ -282,11 +293,9 @@ namespace Catch {
rss << "with expansion:\n";
rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
}
- } else {
- rss << '\n';
}
- if( !result.getMessage().empty() )
+ if( result.hasMessage() )
rss << result.getMessage() << '\n';
for( auto const& msg : stats.infoMessages )
if( msg.type == ResultWas::Info )
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_junit.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_junit.hpp
index a45344de6f8167a59273b3f207a4c1e50a46a723..87c7c5679e4f2ee1ad5fff5f10b55393572987d7 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_junit.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_junit.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_multi.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_multi.cpp
index cf18cb81b0373de0c052bc6174d476d82d8a8721..531902beabcab8cbd9691cfdcba500a435004adf 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_multi.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_multi.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -114,7 +114,6 @@ namespace Catch {
}
}
- // The return value indicates if the messages buffer should be cleared:
void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
const bool reportByDefault =
assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_multi.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_multi.hpp
index e35ea5041e8fb024ef524c54f6906f6cc6681f6d..c43f511f8d3825b4254c5f2b019ac339ec3bb7a5 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_multi.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_multi.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.cpp
index fd1bc76cad823c59c028b208f6b8125a6aa9dd1e..2a3ac957938d69f52b0185cc4ec63dfac43f48d7 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.cpp
@@ -1,13 +1,14 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#include <catch2/reporters/catch_reporter_registrars.hpp>
+#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
#include <catch2/internal/catch_compiler_capabilities.hpp>
namespace Catch {
@@ -26,5 +27,10 @@ namespace Catch {
}
}
+ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
+ getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
+ }
+
+
} // namespace Detail
} // namespace Catch
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.hpp
index e33ecf8b62dcc5c21191ef8215307f8e92a7cb19..a93963f061a1b1806f17ec45f74ce8c825634d54 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_registrars.hpp
@@ -1,15 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_registry_hub.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
#include <catch2/internal/catch_compiler_capabilities.hpp>
#include <catch2/internal/catch_unique_name.hpp>
@@ -36,7 +34,8 @@ namespace Catch {
//! independent on the reporter's concrete type
void registerReporterImpl( std::string const& name,
IReporterFactoryPtr reporterPtr );
-
+ //! Actually registers the factory, independent on listener's concrete type
+ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory );
} // namespace Detail
class IEventListener;
@@ -97,7 +96,7 @@ namespace Catch {
public:
ListenerRegistrar(StringRef listenerName) {
- getMutableRegistryHub().registerListener( Detail::make_unique<TypedListenerFactory>(listenerName) );
+ registerListenerImpl( Detail::make_unique<TypedListenerFactory>(listenerName) );
}
};
}
@@ -118,7 +117,7 @@ namespace Catch {
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
namespace { \
Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
- catch_internal_RegistrarFor )( #listenerType ); \
+ catch_internal_RegistrarFor )( #listenerType##_catch_sr ); \
} \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.cpp
index 8119c3b8f79fa75dfd9ddb14e4985006f0798d6a..9c391b1f4f2576f969d09825012d070d25620946 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,15 +11,22 @@
#include <catch2/catch_test_case_info.hpp>
#include <catch2/internal/catch_reusable_string_stream.hpp>
#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/catch_test_spec.hpp>
+#include <catch2/reporters/catch_reporter_helpers.hpp>
#include <map>
namespace Catch {
namespace {
- std::string createRngSeedString(uint32_t seed) {
+ std::string createMetadataString(IConfig const& config) {
ReusableStringStream sstr;
- sstr << "rng-seed=" << seed;
+ if ( config.testSpec().hasFilters() ) {
+ sstr << "filters='"
+ << config.testSpec()
+ << "' ";
+ }
+ sstr << "rng-seed=" << config.rngSeed();
return sstr.str();
}
}
@@ -27,13 +34,13 @@ namespace Catch {
void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
CumulativeReporterBase::testRunStarting(testRunInfo);
- xml.writeComment( createRngSeedString( m_config->rngSeed() ) );
+ xml.writeComment( createMetadataString( *m_config ) );
xml.startElement("testExecutions");
xml.writeAttribute("version"_sr, '1');
}
void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
- std::map<std::string, std::vector<TestCaseNode const*>> testsPerFile;
+ std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
for ( auto const& child : runNode.children ) {
testsPerFile[child->value.testInfo->lineInfo.file].push_back(
@@ -45,7 +52,7 @@ namespace Catch {
}
}
- void SonarQubeReporter::writeTestFile(std::string const& filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
+ void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
XmlWriter::ScopedElement e = xml.scopedElement("file");
xml.writeAttribute("path"_sr, filename);
@@ -90,7 +97,8 @@ namespace Catch {
void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
AssertionResult const& result = stats.assertionResult;
- if (!result.isOk()) {
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
std::string elementName;
if (okToFail) {
elementName = "skipped";
@@ -101,15 +109,13 @@ namespace Catch {
elementName = "error";
break;
case ResultWas::ExplicitFailure:
- elementName = "failure";
- break;
case ResultWas::ExpressionFailed:
- elementName = "failure";
- break;
case ResultWas::DidntThrowException:
elementName = "failure";
break;
-
+ case ResultWas::ExplicitSkip:
+ elementName = "skipped";
+ break;
// We should never see these here:
case ResultWas::Info:
case ResultWas::Warning:
@@ -129,7 +135,9 @@ namespace Catch {
xml.writeAttribute("message"_sr, messageRss.str());
ReusableStringStream textRss;
- if (stats.totals.assertions.total() > 0) {
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ textRss << "SKIPPED\n";
+ } else {
textRss << "FAILED:\n";
if (result.hasExpression()) {
textRss << '\t' << result.getExpressionInMacro() << '\n';
@@ -139,7 +147,7 @@ namespace Catch {
}
}
- if (!result.getMessage().empty())
+ if (result.hasMessage())
textRss << result.getMessage() << '\n';
for (auto const& msg : stats.infoMessages)
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.hpp
index 32756b488f43a67191dfac9bb84ae084da86809e..cad6deec8ca0a0b82377a01c5e84d4ff90b91ba1 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_sonarqube.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -41,7 +41,7 @@ namespace Catch {
void writeRun( TestRunNode const& groupNode );
- void writeTestFile(std::string const& filename, std::vector<TestCaseNode const*> const& testCaseNodes);
+ void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);
void writeTestCase(TestCaseNode const& testCaseNode);
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.cpp
index a9c898ed8faff456bf79ece61a759b16b8682b45..f1cc425ab49f2583f7b68f9acca7d9bd43781a66 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.hpp
index 76788d8d5c6c4c55f3f5d7730cc28311a9c2e1d5..5448000c70e4c259610e84764a7b0ca7897d8f55 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_streaming_base.hpp
@@ -1,14 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
-#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/reporters/catch_reporter_common_base.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_tap.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_tap.cpp
index 6058f2422ad7216d2fbc7b1ea3d22d0949934b20..67d406fb828335ffe71662ac8590b2e0a06350e2 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_tap.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_tap.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -10,9 +10,10 @@
#include <catch2/internal/catch_string_manip.hpp>
#include <catch2/catch_test_case_info.hpp>
#include <catch2/interfaces/catch_interfaces_config.hpp>
+#include <catch2/catch_test_spec.hpp>
+#include <catch2/reporters/catch_reporter_helpers.hpp>
#include <algorithm>
-#include <iterator>
#include <ostream>
namespace Catch {
@@ -98,6 +99,12 @@ namespace Catch {
printIssue("explicitly"_sr);
printRemainingMessages(Colour::None);
break;
+ case ResultWas::ExplicitSkip:
+ printResultType(tapPassedString);
+ printIssue(" # SKIP"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
@@ -157,7 +164,7 @@ namespace Catch {
// using messages.end() directly (or auto) yields compilation error:
std::vector<MessageInfo>::const_iterator itEnd = messages.end();
- const std::size_t N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+ const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);
stream << colourImpl->guardColour( colour ) << " with "
<< pluralise( N, "message"_sr ) << ':';
@@ -176,7 +183,7 @@ namespace Catch {
private:
std::ostream& stream;
AssertionResult const& result;
- std::vector<MessageInfo> messages;
+ std::vector<MessageInfo> const& messages;
std::vector<MessageInfo>::const_iterator itMessage;
bool printInfoMessages;
std::size_t counter;
@@ -186,6 +193,9 @@ namespace Catch {
} // End anonymous namespace
void TAPReporter::testRunStarting( TestRunInfo const& ) {
+ if ( m_config->testSpec().hasFilters() ) {
+ m_stream << "# filters: " << m_config->testSpec() << '\n';
+ }
m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
}
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_tap.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_tap.hpp
index 0c4b14b4777c6f3c40b79e504109502c81679791..fe45df63e8acffd718e0af45be6bc491681a3e92 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_tap.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_tap.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.cpp
index 142dffbb1d567e26167bd03c754cb79f71f03862..320728007e9fbbab52aec1bd70c3d88a58a0068f 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -59,7 +59,8 @@ namespace Catch {
void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
AssertionResult const& result = assertionStats.assertionResult;
- if (!result.isOk()) {
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
ReusableStringStream msg;
if (!m_headerPrintedForThisSection)
@@ -84,6 +85,9 @@ namespace Catch {
case ResultWas::ExplicitFailure:
msg << "explicit failure";
break;
+ case ResultWas::ExplicitSkip:
+ msg << "explicit skip";
+ break;
// We shouldn't get here because of the isOk() test
case ResultWas::Ok:
@@ -111,18 +115,16 @@ namespace Catch {
" " << result.getExpandedExpression() << '\n';
}
- if (currentTestCaseInfo->okToFail()) {
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ m_stream << "##teamcity[testIgnored";
+ } else if ( currentTestCaseInfo->okToFail() ) {
msg << "- failure ignore as test marked as 'ok to fail'\n";
- m_stream << "##teamcity[testIgnored"
- << " name='" << escape(currentTestCaseInfo->name) << '\''
- << " message='" << escape(msg.str()) << '\''
- << "]\n";
+ m_stream << "##teamcity[testIgnored";
} else {
- m_stream << "##teamcity[testFailed"
- << " name='" << escape(currentTestCaseInfo->name) << '\''
- << " message='" << escape(msg.str()) << '\''
- << "]\n";
+ m_stream << "##teamcity[testFailed";
}
+ m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
+ << " message='" << escape( msg.str() ) << '\'' << "]\n";
}
m_stream.flush();
}
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.hpp
index 5007193bbe87da02937ccc620e15b9f6dd7dd8be..04feb2e6dc03abc953b44a6c2650b899e6ddddf9 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_teamcity.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_xml.cpp b/packages/Catch2/src/catch2/reporters/catch_reporter_xml.cpp
index 1e5def4176cc408f3024c51f743af1664abc8da0..f80cd2470a246ba9ef329c1c9c6451ad04c00ab6 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_xml.cpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_xml.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -56,15 +56,17 @@ namespace Catch {
m_xml.startElement("Catch2TestRun")
.writeAttribute("name"_sr, m_config->name())
.writeAttribute("rng-seed"_sr, m_config->rngSeed())
+ .writeAttribute("xml-format-version"_sr, 3)
.writeAttribute("catch2-version"_sr, libraryVersion());
- if (m_config->testSpec().hasFilters())
- m_xml.writeAttribute( "filters"_sr, serializeFilters( m_config->getTestsOrTags() ) );
+ if ( m_config->testSpec().hasFilters() ) {
+ m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
+ }
}
void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
StreamingReporterBase::testCaseStarting(testInfo);
m_xml.startElement( "TestCase" )
- .writeAttribute( "name"_sr, trim( testInfo.name ) )
+ .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
.writeAttribute( "tags"_sr, testInfo.tagsAsString() );
writeSourceInfo( testInfo.lineInfo );
@@ -78,7 +80,7 @@ namespace Catch {
StreamingReporterBase::sectionStarting( sectionInfo );
if( m_sectionDepth++ > 0 ) {
m_xml.startElement( "Section" )
- .writeAttribute( "name"_sr, trim( sectionInfo.name ) );
+ .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
writeSourceInfo( sectionInfo.lineInfo );
m_xml.ensureTagClosed();
}
@@ -96,19 +98,22 @@ namespace Catch {
// Print any info messages in <Info> tags.
for( auto const& msg : assertionStats.infoMessages ) {
if( msg.type == ResultWas::Info && includeResults ) {
- m_xml.scopedElement( "Info" )
- .writeText( msg.message );
+ auto t = m_xml.scopedElement( "Info" );
+ writeSourceInfo( msg.lineInfo );
+ t.writeText( msg.message );
} else if ( msg.type == ResultWas::Warning ) {
- m_xml.scopedElement( "Warning" )
- .writeText( msg.message );
+ auto t = m_xml.scopedElement( "Warning" );
+ writeSourceInfo( msg.lineInfo );
+ t.writeText( msg.message );
}
}
}
// Drop out if result was successful but we're not printing them.
- if( !includeResults && result.getResultType() != ResultWas::Warning )
+ if ( !includeResults && result.getResultType() != ResultWas::Warning &&
+ result.getResultType() != ResultWas::ExplicitSkip ) {
return;
-
+ }
// Print the expression if there is one.
if( result.hasExpression() ) {
@@ -151,6 +156,12 @@ namespace Catch {
m_xml.writeText( result.getMessage() );
m_xml.endElement();
break;
+ case ResultWas::ExplicitSkip:
+ m_xml.startElement( "Skip" );
+ writeSourceInfo( result.getSourceInfo() );
+ m_xml.writeText( result.getMessage() );
+ m_xml.endElement();
+ break;
default:
break;
}
@@ -161,15 +172,18 @@ namespace Catch {
void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
StreamingReporterBase::sectionEnded( sectionStats );
- if( --m_sectionDepth > 0 ) {
- XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
- e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
- e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
- e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
-
- if ( m_config->showDurations() == ShowDurations::Always )
- e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
-
+ if ( --m_sectionDepth > 0 ) {
+ {
+ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+ e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
+ e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
+ e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
+ e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
+
+ if ( m_config->showDurations() == ShowDurations::Always )
+ e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
+ }
+ // Ends assertion tag
m_xml.endElement();
}
}
@@ -178,14 +192,14 @@ namespace Catch {
StreamingReporterBase::testCaseEnded( testCaseStats );
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
+ e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
if ( m_config->showDurations() == ShowDurations::Always )
e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
-
if( !testCaseStats.stdOut.empty() )
- m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+ m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
if( !testCaseStats.stdErr.empty() )
- m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+ m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
m_xml.endElement();
}
@@ -195,11 +209,13 @@ namespace Catch {
m_xml.scopedElement( "OverallResults" )
.writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
.writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
- .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk );
+ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
+ .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
m_xml.scopedElement( "OverallResultsCases")
.writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
.writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
- .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk );
+ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
+ .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
m_xml.endElement();
}
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporter_xml.hpp b/packages/Catch2/src/catch2/reporters/catch_reporter_xml.hpp
index 573f9321a3daa58f43e9d2c071a81a5706ad96c4..bead7a87161388a3a4c82df363e4ad2839e7b2b6 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporter_xml.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporter_xml.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/src/catch2/reporters/catch_reporters_all.hpp b/packages/Catch2/src/catch2/reporters/catch_reporters_all.hpp
index d3a59eb7dc293106d3968d507d459bce88cf2b3f..16f7bd70cdcae5f28757ad4cc94d98ca9a913ae0 100644
--- a/packages/Catch2/src/catch2/reporters/catch_reporters_all.hpp
+++ b/packages/Catch2/src/catch2/reporters/catch_reporters_all.hpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/CMakeLists.txt b/packages/Catch2/tests/CMakeLists.txt
index 7f5af9949a822031de5da7fa4c4f203a70041b02..7be57abec1856d6b2116f012ed641551ae3e48a9 100644
--- a/packages/Catch2/tests/CMakeLists.txt
+++ b/packages/Catch2/tests/CMakeLists.txt
@@ -77,6 +77,7 @@ endif(MSVC) #Temporary workaround
# Please keep these ordered alphabetically
set(TEST_SOURCES
${SELF_TEST_DIR}/TestRegistrations.cpp
+ ${SELF_TEST_DIR}/IntrospectiveTests/Algorithms.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/Clara.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/CmdLine.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/CmdLineHelpers.tests.cpp
@@ -85,11 +86,13 @@ set(TEST_SOURCES
${SELF_TEST_DIR}/IntrospectiveTests/FloatingPoint.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/GeneratorsImpl.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/InternalBenchmark.tests.cpp
+ ${SELF_TEST_DIR}/IntrospectiveTests/Parse.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/PartTracker.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/RandomNumberGeneration.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/Reporters.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/Tag.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
+ ${SELF_TEST_DIR}/IntrospectiveTests/TestSpec.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/TestSpecParser.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/TextFlow.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/Sharding.tests.cpp
@@ -97,8 +100,10 @@ set(TEST_SOURCES
${SELF_TEST_DIR}/IntrospectiveTests/String.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/StringManip.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/Xml.tests.cpp
+ ${SELF_TEST_DIR}/IntrospectiveTests/Traits.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/ToString.tests.cpp
${SELF_TEST_DIR}/IntrospectiveTests/UniquePtr.tests.cpp
+ ${SELF_TEST_DIR}/helpers/parse_test_spec.cpp
${SELF_TEST_DIR}/TimingTests/Sleep.tests.cpp
${SELF_TEST_DIR}/UsageTests/Approx.tests.cpp
${SELF_TEST_DIR}/UsageTests/BDD.tests.cpp
@@ -112,6 +117,7 @@ set(TEST_SOURCES
${SELF_TEST_DIR}/UsageTests/Generators.tests.cpp
${SELF_TEST_DIR}/UsageTests/Message.tests.cpp
${SELF_TEST_DIR}/UsageTests/Misc.tests.cpp
+ ${SELF_TEST_DIR}/UsageTests/Skip.tests.cpp
${SELF_TEST_DIR}/UsageTests/ToStringByte.tests.cpp
${SELF_TEST_DIR}/UsageTests/ToStringChrono.tests.cpp
${SELF_TEST_DIR}/UsageTests/ToStringGeneral.tests.cpp
@@ -127,6 +133,12 @@ set(TEST_SOURCES
${SELF_TEST_DIR}/UsageTests/Matchers.tests.cpp
)
+set(TEST_HEADERS
+ ${SELF_TEST_DIR}/helpers/parse_test_spec.hpp
+ ${SELF_TEST_DIR}/helpers/range_test_helpers.hpp
+ ${SELF_TEST_DIR}/helpers/type_with_lit_0_comparisons.hpp
+)
+
# Specify the headers, too, so CLion recognises them as project files
set(HEADERS
@@ -144,7 +156,8 @@ set(HEADERS
include(CTest)
-add_executable(SelfTest ${TEST_SOURCES})
+add_executable(SelfTest ${TEST_SOURCES} ${TEST_HEADERS})
+target_include_directories(SelfTest PRIVATE ${SELF_TEST_DIR})
target_link_libraries(SelfTest PRIVATE Catch2WithMain)
if (BUILD_SHARED_LIBS AND WIN32)
add_custom_command(TARGET SelfTest PRE_LINK
@@ -165,7 +178,7 @@ endif()
add_test(NAME RunTests COMMAND $<TARGET_FILE:SelfTest> --order rand --rng-seed time)
set_tests_properties(RunTests PROPERTIES
FAIL_REGULAR_EXPRESSION "Filters:"
- COST 60
+ COST 15
)
# Because CTest does not allow us to check both return code _and_ expected
@@ -247,7 +260,7 @@ add_test(NAME TestSpecs::CombiningMatchingAndNonMatchingIsOk-1 COMMAND $<TARGET_
add_test(NAME TestSpecs::CombiningMatchingAndNonMatchingIsOk-2 COMMAND $<TARGET_FILE:SelfTest> Tracker, "___nonexistent_test___")
set_tests_properties(TestSpecs::CombiningMatchingAndNonMatchingIsOk-2 PROPERTIES
- PASS_REGULAR_EXPRESSION "No test cases matched '___nonexistent_test___'"
+ PASS_REGULAR_EXPRESSION "No test cases matched '\"___nonexistent_test___\"'"
FAIL_REGULAR_EXPRESSION "No tests ran"
)
@@ -262,6 +275,18 @@ add_test(NAME TestSpecs::OverrideFailureWithNoMatchedTests
COMMAND $<TARGET_FILE:SelfTest> "___nonexistent_test___" --allow-running-no-tests
)
+add_test(NAME TestSpecs::OverrideAllSkipFailure
+ COMMAND $<TARGET_FILE:SelfTest> "tests can be skipped dynamically at runtime" --allow-running-no-tests
+)
+
+add_test(NAME TestSpecs::NonMatchingTestSpecIsRoundTrippable
+ COMMAND $<TARGET_FILE:SelfTest> Tracker, "this test does not exist" "[nor does this tag]"
+)
+set_tests_properties(TestSpecs::NonMatchingTestSpecIsRoundTrippable
+ PROPERTIES
+ PASS_REGULAR_EXPRESSION "No test cases matched '\"this test does not exist\" \\[nor does this tag\\]'"
+)
+
add_test(NAME Warnings::UnmatchedTestSpecIsAccepted
COMMAND $<TARGET_FILE:SelfTest> Tracker --warn UnmatchedTestSpec
)
@@ -325,17 +350,27 @@ set_tests_properties(FilteredSection::GeneratorsDontCauseInfiniteLoop-2
)
# AppVeyor has a Python 2.7 in path, but doesn't have .py files as autorunnable
-add_test(NAME ApprovalTests COMMAND ${PYTHON_EXECUTABLE} ${CATCH_DIR}/tools/scripts/approvalTests.py $<TARGET_FILE:SelfTest>)
+add_test(NAME ApprovalTests
+ COMMAND
+ ${PYTHON_EXECUTABLE}
+ ${CATCH_DIR}/tools/scripts/approvalTests.py
+ $<TARGET_FILE:SelfTest>
+ "${CMAKE_CURRENT_BINARY_DIR}"
+)
+
set_tests_properties(ApprovalTests
PROPERTIES
FAIL_REGULAR_EXPRESSION "Results differed"
- COST 120 # We know that this is either the most, or second most,
- # expensive test in the test suite, so we give it high estimate for CI runs
+
+ # This is the most expensive test in the basic test suite, so we give
+ # it high cost estimate so that CI runs it as one of the first ones,
+ # for better parallelization.
+ COST 30
LABELS "uses-python"
)
add_test(NAME RegressionCheck-1670 COMMAND $<TARGET_FILE:SelfTest> "#1670 regression check" -c A -r compact)
-set_tests_properties(RegressionCheck-1670 PROPERTIES PASS_REGULAR_EXPRESSION "Passed 1 test case with 2 assertions.")
+set_tests_properties(RegressionCheck-1670 PROPERTIES PASS_REGULAR_EXPRESSION "All tests passed \\(2 assertions in 1 test case\\)")
add_test(NAME VersionCheck COMMAND $<TARGET_FILE:SelfTest> -h)
set_tests_properties(VersionCheck PROPERTIES PASS_REGULAR_EXPRESSION "Catch2 v${PROJECT_VERSION}")
@@ -595,6 +630,23 @@ foreach (reporterName # "Automake" - the simple .trs format does not support any
"TAP"
# "TeamCity" - does not seem to support test suite-level metadata/comments
"XML")
+
+ add_test(NAME "Reporters:Filters:${reporterName}"
+ COMMAND
+ $<TARGET_FILE:SelfTest> [comparisons][string-case] "CaseInsensitiveLess is case insensitive"
+ --reporter ${reporterName}
+ )
+ # Different regex for these two reporters, because the commas end up xml-escaped
+ if (reporterName MATCHES "JUnit|XML")
+ set(testCaseNameFormat ""CaseInsensitiveLess is case insensitive"")
+ else()
+ set(testCaseNameFormat "\"CaseInsensitiveLess is case insensitive\"")
+ endif()
+ set_tests_properties("Reporters:Filters:${reporterName}"
+ PROPERTIES
+ PASS_REGULAR_EXPRESSION "[fF]ilters.+\\[comparisons\\] \\[string-case\\] ${testCaseNameFormat}"
+ )
+
add_test(NAME "Reporters:RngSeed:${reporterName}"
COMMAND
$<TARGET_FILE:SelfTest> "Factorials are computed"
diff --git a/packages/Catch2/tests/ExtraTests/CMakeLists.txt b/packages/Catch2/tests/ExtraTests/CMakeLists.txt
index f1a02af3f6a1fc607ea8ae65a3c3aa2d876e015e..2a810e2584ca67d2449c2965ea32a3877b595011 100644
--- a/packages/Catch2/tests/ExtraTests/CMakeLists.txt
+++ b/packages/Catch2/tests/ExtraTests/CMakeLists.txt
@@ -2,7 +2,7 @@
# Build extra tests.
#
-cmake_minimum_required( VERSION 3.5 )
+cmake_minimum_required( VERSION 3.10 )
project( Catch2ExtraTests LANGUAGES CXX )
@@ -150,6 +150,29 @@ set_tests_properties(NO_CATCH_CONFIG_BAZEL_REPORTER-1
ENVIRONMENT "BAZEL_TEST=1"
)
+add_test(NAME BazelEnv::TESTBRIDGE_TEST_ONLY
+ COMMAND
+ $<TARGET_FILE:BazelReporterNoCatchConfig>
+)
+set_tests_properties(BazelEnv::TESTBRIDGE_TEST_ONLY
+ PROPERTIES
+ ENVIRONMENT "BAZEL_TEST=1;TESTBRIDGE_TEST_ONLY=Passing test case"
+ PASS_REGULAR_EXPRESSION "All tests passed \\(1 assertion in 1 test case\\)"
+)
+
+
+add_test(NAME BazelEnv::Sharding
+ COMMAND
+ "${PYTHON_EXECUTABLE}" "${CATCH_DIR}/tests/TestScripts/testBazelSharding.py"
+ $<TARGET_FILE:BazelReporterNoCatchConfig>
+ "${CMAKE_CURRENT_BINARY_DIR}"
+)
+set_tests_properties(BazelEnv::Sharding
+ PROPERTIES
+ LABELS "uses-python"
+)
+
+
# The default handler on Windows leads to the just-in-time debugger firing,
# which makes this test unsuitable for CI and headless runs, as it opens
# up an interactive dialog.
@@ -187,7 +210,7 @@ add_test(NAME DeferredStaticChecks COMMAND DeferredStaticChecks -r compact)
set_tests_properties(
DeferredStaticChecks
PROPERTIES
- PASS_REGULAR_EXPRESSION "Failed 1 test case, failed all 3 assertions."
+ PASS_REGULAR_EXPRESSION "test cases: 1 \\| 1 failed\nassertions: 3 \\| 3 failed"
)
@@ -219,9 +242,6 @@ set_tests_properties(
if (MSVC)
# This test fails if it does not compile and succeeds otherwise
add_executable(WindowsHeader ${TESTS_DIR}/X90-WindowsHeaderInclusion.cpp)
- set_property( TARGET WindowsHeader PROPERTY CXX_STANDARD 14 )
- set_property( TARGET WindowsHeader PROPERTY CXX_STANDARD_REQUIRED ON )
- set_property( TARGET WindowsHeader PROPERTY CXX_EXTENSIONS OFF )
target_link_libraries( WindowsHeader Catch2WithMain )
add_test(NAME WindowsHeader COMMAND WindowsHeader -r compact)
list(APPEND CATCH_WARNING_TARGETS ${EXTRA_TEST_BINARIES} WindowsHeader)
@@ -249,6 +269,7 @@ set_tests_properties(
BenchmarksInCumulativeReporter
PROPERTIES
PASS_REGULAR_EXPRESSION "1\n2\n3\n4\n5\n"
+ COST 30
)
@@ -447,6 +468,17 @@ set_tests_properties(
)
+add_executable(AssertionStartingEventGoesBeforeAssertionIsEvaluated
+ X20-AssertionStartingEventGoesBeforeAssertionIsEvaluated.cpp
+)
+target_link_libraries(AssertionStartingEventGoesBeforeAssertionIsEvaluated
+ PRIVATE Catch2::Catch2WithMain
+)
+add_test(
+ NAME ReporterEvents::AssertionStartingHappensBeforeAssertionIsEvaluated
+ COMMAND $<TARGET_FILE:AssertionStartingEventGoesBeforeAssertionIsEvaluated>
+)
+
#add_executable(DebugBreakMacros ${TESTS_DIR}/X12-CustomDebugBreakMacro.cpp)
#target_link_libraries(DebugBreakMacros Catch2)
#add_test(NAME DebugBreakMacros COMMAND DebugBreakMacros --break)
@@ -467,15 +499,32 @@ set_tests_properties(TestSpecs::EmptySpecWithNoTestsFails
PROPERTIES
WILL_FAIL ON
)
+
add_test(
NAME TestSpecs::OverrideFailureWithEmptySpec
COMMAND $<TARGET_FILE:NoTests> --allow-running-no-tests
)
+
add_test(
NAME List::Listeners::WorksWithoutRegisteredListeners
COMMAND $<TARGET_FILE:NoTests> --list-listeners
)
+
+
+add_executable(AllSkipped ${TESTS_DIR}/X93-AllSkipped.cpp)
+target_link_libraries(AllSkipped PRIVATE Catch2::Catch2WithMain)
+
+add_test(
+ NAME TestSpecs::SkippingAllTestsFails
+ COMMAND $<TARGET_FILE:AllSkipped>
+)
+set_tests_properties(TestSpecs::SkippingAllTestsFails
+ PROPERTIES
+ WILL_FAIL ON
+)
+
set( EXTRA_TEST_BINARIES
+ AllSkipped
PrefixedMacros
DisabledMacros
DisabledExceptions-DefaultHandler
@@ -491,13 +540,6 @@ set( EXTRA_TEST_BINARIES
# DebugBreakMacros
)
-# Shared config
-foreach( test ${EXTRA_TEST_BINARIES} )
- set_property( TARGET ${test} PROPERTY CXX_STANDARD 14 )
- set_property( TARGET ${test} PROPERTY CXX_STANDARD_REQUIRED ON )
- set_property( TARGET ${test} PROPERTY CXX_EXTENSIONS OFF )
-endforeach()
-
# Notice that we are modifying EXTRA_TEST_BINARIES destructively, do not
# use it after this point!
list(FILTER EXTRA_TEST_BINARIES EXCLUDE REGEX "DisabledExceptions.*")
@@ -514,9 +556,6 @@ add_executable(AmalgamatedTestCompilation
${CATCH_DIR}/extras/catch_amalgamated.cpp
)
target_include_directories(AmalgamatedTestCompilation PRIVATE ${CATCH_DIR}/extras)
-set_property( TARGET AmalgamatedTestCompilation PROPERTY CXX_STANDARD 14 )
-set_property( TARGET AmalgamatedTestCompilation PROPERTY CXX_STANDARD_REQUIRED ON )
-set_property( TARGET AmalgamatedTestCompilation PROPERTY CXX_EXTENSIONS OFF )
add_test(NAME AmalgamatedFileTest COMMAND AmalgamatedTestCompilation)
set_tests_properties(
diff --git a/packages/Catch2/tests/ExtraTests/X01-PrefixedMacros.cpp b/packages/Catch2/tests/ExtraTests/X01-PrefixedMacros.cpp
index 65235194c3cc4878ba05105212aee0612476a9d2..d1c246ecb48f7adadb255f1d9cbea96fd5a30d8a 100644
--- a/packages/Catch2/tests/ExtraTests/X01-PrefixedMacros.cpp
+++ b/packages/Catch2/tests/ExtraTests/X01-PrefixedMacros.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X02-DisabledMacros.cpp b/packages/Catch2/tests/ExtraTests/X02-DisabledMacros.cpp
index 37d35e11cc10c9e83ccb3e4de0e7c846e9efa4fe..68bc2add60289ed3e872932d06f96f5eb41303ce 100644
--- a/packages/Catch2/tests/ExtraTests/X02-DisabledMacros.cpp
+++ b/packages/Catch2/tests/ExtraTests/X02-DisabledMacros.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X03-DisabledExceptions-DefaultHandler.cpp b/packages/Catch2/tests/ExtraTests/X03-DisabledExceptions-DefaultHandler.cpp
index 74b651c7504a222e083000144ee8ab8dccc3f2cc..5b6d4b126f101c7295e58db3bb578cca5809369d 100644
--- a/packages/Catch2/tests/ExtraTests/X03-DisabledExceptions-DefaultHandler.cpp
+++ b/packages/Catch2/tests/ExtraTests/X03-DisabledExceptions-DefaultHandler.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X04-DisabledExceptions-CustomHandler.cpp b/packages/Catch2/tests/ExtraTests/X04-DisabledExceptions-CustomHandler.cpp
index 725440ec34d707e757c8d21255279e6aad0edca4..e1f1e703a629dd5cac37bd3419a692e5668c526a 100644
--- a/packages/Catch2/tests/ExtraTests/X04-DisabledExceptions-CustomHandler.cpp
+++ b/packages/Catch2/tests/ExtraTests/X04-DisabledExceptions-CustomHandler.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X05-DeferredStaticChecks.cpp b/packages/Catch2/tests/ExtraTests/X05-DeferredStaticChecks.cpp
index 62ceb4a770cf53de8e6d1c49217169bbac97e897..8005dbcfa1363b68ab96bee2ccb6391df6a07d04 100644
--- a/packages/Catch2/tests/ExtraTests/X05-DeferredStaticChecks.cpp
+++ b/packages/Catch2/tests/ExtraTests/X05-DeferredStaticChecks.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X10-FallbackStringifier.cpp b/packages/Catch2/tests/ExtraTests/X10-FallbackStringifier.cpp
index 61ad62ea10a701e20e4ae2bb8a8c5cec1fc24ad7..8525a81369c179f86acd934891b17e893551ecb0 100644
--- a/packages/Catch2/tests/ExtraTests/X10-FallbackStringifier.cpp
+++ b/packages/Catch2/tests/ExtraTests/X10-FallbackStringifier.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X11-DisableStringification.cpp b/packages/Catch2/tests/ExtraTests/X11-DisableStringification.cpp
index 97dcea7b68e71072e62e08724c1905dd51da7ec5..f89962771bb3bbcf13b4b6398f7a2b00ee374299 100644
--- a/packages/Catch2/tests/ExtraTests/X11-DisableStringification.cpp
+++ b/packages/Catch2/tests/ExtraTests/X11-DisableStringification.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X12-CustomDebugBreakMacro.cpp b/packages/Catch2/tests/ExtraTests/X12-CustomDebugBreakMacro.cpp
index e52c1c2b6d8dedc6584e99bb7e6b7482b3f345e3..e6d3e38b002392c2d7d1b80a6e19cc259297fddd 100644
--- a/packages/Catch2/tests/ExtraTests/X12-CustomDebugBreakMacro.cpp
+++ b/packages/Catch2/tests/ExtraTests/X12-CustomDebugBreakMacro.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X20-AssertionStartingEventGoesBeforeAssertionIsEvaluated.cpp b/packages/Catch2/tests/ExtraTests/X20-AssertionStartingEventGoesBeforeAssertionIsEvaluated.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef5b46b95de33876b1356240a460e06e219f3d0e
--- /dev/null
+++ b/packages/Catch2/tests/ExtraTests/X20-AssertionStartingEventGoesBeforeAssertionIsEvaluated.cpp
@@ -0,0 +1,81 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+/**\file
+ * TODO: FIXES Registers custom reporter that reports testCase* events
+ *
+ * The resulting executable can then be used by an external Python script
+ * to verify that testCase{Starting,Ended} and testCasePartial{Starting,Ended}
+ * events are properly nested.
+ */
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/reporters/catch_reporter_event_listener.hpp>
+#include <catch2/reporters/catch_reporter_registrars.hpp>
+#include <catch2/matchers/catch_matchers_predicate.hpp>
+
+namespace {
+
+ static size_t assertion_starting_events_seen = 0;
+
+ // TODO: custom matcher to check that "assertion_starting_events_seen" has
+ // the right number of checks
+
+ class AssertionStartingListener : public Catch::EventListenerBase {
+ public:
+ AssertionStartingListener( Catch::IConfig const* config ):
+ EventListenerBase( config ) {}
+
+ void assertionStarting( Catch::AssertionInfo const& ) override {
+ ++assertion_starting_events_seen;
+ }
+ };
+
+ static bool f1() {
+ return assertion_starting_events_seen == 1;
+ }
+
+ static void f2() {
+ if ( assertion_starting_events_seen != 2 ) { throw 1; }
+ }
+
+ static void f3() {
+ if ( assertion_starting_events_seen == 3 ) { throw 1; }
+ }
+
+ static bool f4() { return assertion_starting_events_seen == 4; }
+
+ static void f5() { throw assertion_starting_events_seen; }
+
+} // anonymous namespace
+
+CATCH_REGISTER_LISTENER( AssertionStartingListener )
+
+TEST_CASE() {
+ // **IMPORTANT**
+ // The order of assertions below matters.
+ REQUIRE( f1() );
+ REQUIRE_NOTHROW( f2() );
+ REQUIRE_THROWS( f3() );
+ REQUIRE_THAT( f4(),
+ Catch::Matchers::Predicate<bool>( []( bool b ) { return b; } ) );
+ REQUIRE_THROWS_MATCHES(
+ f5(), size_t, Catch::Matchers::Predicate<size_t>( []( size_t i ) {
+ return i == 5;
+ } ) );
+
+ CAPTURE( assertion_starting_events_seen ); // **not** an assertion
+ INFO( "some info msg" ); // **not** an assertion
+ WARN( "warning! warning!" ); // assertion-like message
+ SUCCEED(); // assertion-like message
+
+ // We skip FAIL/SKIP and so on, which fail the test.
+
+ // This require will also increment the count once
+ REQUIRE( assertion_starting_events_seen == 8 );
+}
diff --git a/packages/Catch2/tests/ExtraTests/X21-PartialTestCaseEvents.cpp b/packages/Catch2/tests/ExtraTests/X21-PartialTestCaseEvents.cpp
index 686b50b1d68a35b83159b63d7b934350eb850915..aa5204c95c8d952f6422e31bb9635c3f68dd894d 100644
--- a/packages/Catch2/tests/ExtraTests/X21-PartialTestCaseEvents.cpp
+++ b/packages/Catch2/tests/ExtraTests/X21-PartialTestCaseEvents.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X22-BenchmarksInCumulativeReporter.cpp b/packages/Catch2/tests/ExtraTests/X22-BenchmarksInCumulativeReporter.cpp
index c75d891e5e15de2ef6990c1107ddd264843a4e73..af03ce30ae97ff456cdd6dd84e487e6b26a7f765 100644
--- a/packages/Catch2/tests/ExtraTests/X22-BenchmarksInCumulativeReporter.cpp
+++ b/packages/Catch2/tests/ExtraTests/X22-BenchmarksInCumulativeReporter.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X23-CasingInReporterNames.cpp b/packages/Catch2/tests/ExtraTests/X23-CasingInReporterNames.cpp
index 0e13f205b22d97b839c1743ffea727c0d54b5b6f..30523739506cfda626ad0307e13efccbf46631c6 100644
--- a/packages/Catch2/tests/ExtraTests/X23-CasingInReporterNames.cpp
+++ b/packages/Catch2/tests/ExtraTests/X23-CasingInReporterNames.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X24-ListenerStdoutCaptureInMultireporter.cpp b/packages/Catch2/tests/ExtraTests/X24-ListenerStdoutCaptureInMultireporter.cpp
index 605458515604b374aa7988282f3477b54c37f4ca..ffb706e9c19f79f81b3bd5b09d2a0e7dfca919ee 100644
--- a/packages/Catch2/tests/ExtraTests/X24-ListenerStdoutCaptureInMultireporter.cpp
+++ b/packages/Catch2/tests/ExtraTests/X24-ListenerStdoutCaptureInMultireporter.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X25-ListenerCanAskForCapturedStdout.cpp b/packages/Catch2/tests/ExtraTests/X25-ListenerCanAskForCapturedStdout.cpp
index a4a55ad75dbe919bd3d459f0fd16bb197a0978fa..de75ef4e74e545360e5ee02f39ad884f3860b019 100644
--- a/packages/Catch2/tests/ExtraTests/X25-ListenerCanAskForCapturedStdout.cpp
+++ b/packages/Catch2/tests/ExtraTests/X25-ListenerCanAskForCapturedStdout.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X26-ReporterPreferencesForPassingAssertionsIsRespected.cpp b/packages/Catch2/tests/ExtraTests/X26-ReporterPreferencesForPassingAssertionsIsRespected.cpp
index 01aca7c0c8f29262c546183365fe821371fbff3a..90a5885e9229fca67228be098c7ef2c01e48ce14 100644
--- a/packages/Catch2/tests/ExtraTests/X26-ReporterPreferencesForPassingAssertionsIsRespected.cpp
+++ b/packages/Catch2/tests/ExtraTests/X26-ReporterPreferencesForPassingAssertionsIsRespected.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X27-CapturedStdoutInTestCaseEvents.cpp b/packages/Catch2/tests/ExtraTests/X27-CapturedStdoutInTestCaseEvents.cpp
index cb29be0c1ed265d44763831a6c2ad47659daf998..61aaa02a8ac0501e2e8cd57a7431bd9e2387a491 100644
--- a/packages/Catch2/tests/ExtraTests/X27-CapturedStdoutInTestCaseEvents.cpp
+++ b/packages/Catch2/tests/ExtraTests/X27-CapturedStdoutInTestCaseEvents.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X28-ListenersGetEventsBeforeReporters.cpp b/packages/Catch2/tests/ExtraTests/X28-ListenersGetEventsBeforeReporters.cpp
index c8102edb23d6c5084564993f13b15b5cc2a4b504..4098c8b89f356286de87a0fad6ef0c3aa73b8839 100644
--- a/packages/Catch2/tests/ExtraTests/X28-ListenersGetEventsBeforeReporters.cpp
+++ b/packages/Catch2/tests/ExtraTests/X28-ListenersGetEventsBeforeReporters.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X29-CustomArgumentsForReporters.cpp b/packages/Catch2/tests/ExtraTests/X29-CustomArgumentsForReporters.cpp
index d3af7dc75bf3758a45eeaf6dc432ff52323af7eb..9bd816efcbddfae3f48b4f6566993db3ff6030b7 100644
--- a/packages/Catch2/tests/ExtraTests/X29-CustomArgumentsForReporters.cpp
+++ b/packages/Catch2/tests/ExtraTests/X29-CustomArgumentsForReporters.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X30-BazelReporter.cpp b/packages/Catch2/tests/ExtraTests/X30-BazelReporter.cpp
index 6a6168dbe4c89b990068eb92398bd43040d02218..2a259416a006a94740e7b803eaaafa3c6022f20d 100644
--- a/packages/Catch2/tests/ExtraTests/X30-BazelReporter.cpp
+++ b/packages/Catch2/tests/ExtraTests/X30-BazelReporter.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X31-DuplicatedTestCases.cpp b/packages/Catch2/tests/ExtraTests/X31-DuplicatedTestCases.cpp
index 2235ca8396d57363625ae5e831fc8bea50489139..0d091752f2eb811c998cffe1a266b9ea6e11d416 100644
--- a/packages/Catch2/tests/ExtraTests/X31-DuplicatedTestCases.cpp
+++ b/packages/Catch2/tests/ExtraTests/X31-DuplicatedTestCases.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X32-DuplicatedTestCasesDifferentTags.cpp b/packages/Catch2/tests/ExtraTests/X32-DuplicatedTestCasesDifferentTags.cpp
index 6a4246be51be9bc2549c58f71c113693b8485cd4..b0aa4171a82f01b40b856494778bfb5ad8100f9c 100644
--- a/packages/Catch2/tests/ExtraTests/X32-DuplicatedTestCasesDifferentTags.cpp
+++ b/packages/Catch2/tests/ExtraTests/X32-DuplicatedTestCasesDifferentTags.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X33-DuplicatedTestCaseMethods.cpp b/packages/Catch2/tests/ExtraTests/X33-DuplicatedTestCaseMethods.cpp
index ff6660a8a1c478f279a6611d8ffec2b6a64cac10..d3c3449ac7518cd84a53a17abeff77f20d505d46 100644
--- a/packages/Catch2/tests/ExtraTests/X33-DuplicatedTestCaseMethods.cpp
+++ b/packages/Catch2/tests/ExtraTests/X33-DuplicatedTestCaseMethods.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X34-DuplicatedTestCaseMethodsDifferentFixtures.cpp b/packages/Catch2/tests/ExtraTests/X34-DuplicatedTestCaseMethodsDifferentFixtures.cpp
index b2021f5fbff85fa564d82d138c8bb298969f456c..397cf15d2f6839a159365e021210ab8c45487922 100644
--- a/packages/Catch2/tests/ExtraTests/X34-DuplicatedTestCaseMethodsDifferentFixtures.cpp
+++ b/packages/Catch2/tests/ExtraTests/X34-DuplicatedTestCaseMethodsDifferentFixtures.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X35-DuplicatedReporterNames.cpp b/packages/Catch2/tests/ExtraTests/X35-DuplicatedReporterNames.cpp
index cc0dd0b97f5d67df726bae8d320274443fb7758d..a978448a39c09b19b6a56ae13d2cebb7499cfc81 100644
--- a/packages/Catch2/tests/ExtraTests/X35-DuplicatedReporterNames.cpp
+++ b/packages/Catch2/tests/ExtraTests/X35-DuplicatedReporterNames.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X90-WindowsHeaderInclusion.cpp b/packages/Catch2/tests/ExtraTests/X90-WindowsHeaderInclusion.cpp
index 739b34d409335694e119ca78fcc35bd954948692..dff542ae1f93e8dbdb83f2542583e2c765247659 100644
--- a/packages/Catch2/tests/ExtraTests/X90-WindowsHeaderInclusion.cpp
+++ b/packages/Catch2/tests/ExtraTests/X90-WindowsHeaderInclusion.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X91-AmalgamatedCatch.cpp b/packages/Catch2/tests/ExtraTests/X91-AmalgamatedCatch.cpp
index d77f55d5ba93013f499b57e6dbce72b79ada8641..c00462be7444adc06b887bf52a853149c5c9960f 100644
--- a/packages/Catch2/tests/ExtraTests/X91-AmalgamatedCatch.cpp
+++ b/packages/Catch2/tests/ExtraTests/X91-AmalgamatedCatch.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X92-NoTests.cpp b/packages/Catch2/tests/ExtraTests/X92-NoTests.cpp
index fc6bf597ac5a9aabd7497d690c4df9c6757feff6..9591e540b80786a5209232ed6199c90d707eb43e 100644
--- a/packages/Catch2/tests/ExtraTests/X92-NoTests.cpp
+++ b/packages/Catch2/tests/ExtraTests/X92-NoTests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/ExtraTests/X93-AllSkipped.cpp b/packages/Catch2/tests/ExtraTests/X93-AllSkipped.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e7d0afe66c4c30c0a710c96650a5c84451c74aa
--- /dev/null
+++ b/packages/Catch2/tests/ExtraTests/X93-AllSkipped.cpp
@@ -0,0 +1,16 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE( "this test case is being skipped" ) { SKIP(); }
+
+TEST_CASE( "all sections in this test case are being skipped" ) {
+ SECTION( "A" ) { SKIP(); }
+ SECTION( "B" ) { SKIP(); }
+}
diff --git a/packages/Catch2/tests/SelfTest/Baselines/automake.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/automake.sw.approved.txt
index b8b5956601f0348b9da829840b5490bac8cb6242..6b5938a67b2402df688c5aabd08f5aa23e58dbb7 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/automake.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/automake.sw.approved.txt
@@ -25,6 +25,7 @@ Nor would this
:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - double
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - float
+:test-result: XFAIL #2615 - Throwing in constructor generator fails test case but does not abort
:test-result: XFAIL #748 - captures with unexpected exceptions
:test-result: PASS #809
:test-result: PASS #833
@@ -129,8 +130,8 @@ Nor would this
:test-result: FAIL Custom std-exceptions can be custom translated
:test-result: PASS Default scale is invisible to comparison
:test-result: PASS Directly creating an EnumInfo
+:test-result: SKIP Empty generators can SKIP in constructor
:test-result: PASS Empty stream name opens cout stream
-:test-result: PASS Empty tag is not allowed
:test-result: FAIL EndsWith string matcher
:test-result: PASS Enums can quickly have stringification enabled using REGISTER_ENUM
:test-result: PASS Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
@@ -142,6 +143,7 @@ Nor would this
:test-result: PASS Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified
:test-result: FAIL Exception matchers that fail
:test-result: PASS Exception matchers that succeed
+:test-result: PASS Exception message can be matched
:test-result: PASS Exception messages can be tested for
:test-result: PASS Exceptions matchers
:test-result: FAIL Expected exceptions that don't throw or unexpected exceptions fail the test
@@ -149,6 +151,7 @@ Nor would this
:test-result: FAIL FAIL does not require an argument
:test-result: FAIL FAIL_CHECK does not abort the test
:test-result: PASS Factorials are computed
+:test-result: PASS Filter generator throws exception for empty generator
:test-result: PASS Floating point matchers: double
:test-result: PASS Floating point matchers: float
:test-result: PASS Generators -- adapters
@@ -188,7 +191,7 @@ Nor would this
:test-result: PASS Our PCG implementation provides expected results for known seeds
:test-result: FAIL Output from all sections is reported
:test-result: PASS Overloaded comma or address-of operators are not used
-:test-result: PASS Parse test names and tags
+:test-result: PASS Parse uints
:test-result: PASS Parsed tags are matched case insensitive
:test-result: PASS Parsing sharding-related cli flags
:test-result: PASS Parsing tags with non-alphabetical characters is pass-through
@@ -268,6 +271,7 @@ Message from section two
:test-result: FAIL Thrown string literals are translated
:test-result: PASS Tracker
:test-result: PASS Trim strings
+:test-result: PASS Type conversions of RangeEquals and similar
:test-result: FAIL Unexpected exceptions can be translated
:test-result: PASS Upcasting special member functions
:test-result: PASS Usage of AllMatch range matcher
@@ -276,6 +280,8 @@ Message from section two
:test-result: PASS Usage of AnyTrue range matcher
:test-result: PASS Usage of NoneMatch range matcher
:test-result: PASS Usage of NoneTrue range matcher
+:test-result: PASS Usage of RangeEquals range matcher
+:test-result: PASS Usage of UnorderedRangeEquals range matcher
:test-result: PASS Usage of the SizeIs range matcher
:test-result: PASS Use a custom approx
:test-result: PASS Variadic macros
@@ -296,6 +302,7 @@ Message from section two
:test-result: PASS X/level/1/b
:test-result: PASS XmlEncode
:test-result: PASS XmlWriter writes boolean attributes as true/false
+:test-result: SKIP a succeeding test can still be skipped
:test-result: PASS analyse no analysis
:test-result: PASS array<int, N> -> toString
:test-result: PASS benchmark function call
@@ -308,10 +315,14 @@ Message from section two
:test-result: PASS comparisons between const int variables
:test-result: PASS comparisons between int variables
:test-result: PASS convertToBits
+:test-result: SKIP dynamic skipping works with generators
:test-result: PASS empty tags are not allowed
:test-result: PASS erfc_inv
:test-result: PASS estimate_clock_resolution
:test-result: PASS even more nested SECTION tests
+:test-result: XFAIL failed assertions before SKIP cause test case to fail
+:test-result: XFAIL failing for some generator values causes entire test case to fail
+:test-result: XFAIL failing in some unskipped sections causes entire test case to fail
:test-result: FAIL first tag
loose text artifact
:test-result: FAIL has printf
@@ -330,6 +341,10 @@ loose text artifact
:test-result: FAIL mix info, unscoped info and warning
:test-result: FAIL more nested SECTION tests
:test-result: PASS nested SECTION tests
+a!
+b1!
+!
+:test-result: FAIL nested sections can be skipped dynamically at runtime
:test-result: PASS non streamable - with conv. op
:test-result: PASS non-copyable objects
:test-result: PASS normal_cdf
@@ -351,9 +366,11 @@ loose text artifact
:test-result: PASS run_for_at_least, chronometer
:test-result: PASS run_for_at_least, int
:test-result: FAIL second tag
+:test-result: SKIP sections can be skipped dynamically at runtime
:test-result: FAIL send a single char to INFO
:test-result: FAIL sends information to INFO
:test-result: PASS shortened hide tags are split apart
+:test-result: SKIP skipped tests can optionally provide a reason
:test-result: PASS splitString
:test-result: FAIL stacks unscoped info in loops
:test-result: PASS startsWith
@@ -375,6 +392,7 @@ loose text artifact
:test-result: PASS strlen3
:test-result: PASS tables
:test-result: PASS tags with dots in later positions are not parsed as hidden
+:test-result: SKIP tests can be skipped dynamically at runtime
:test-result: FAIL thrown std::strings are translated
:test-result: PASS toString on const wchar_t const pointer returns the string contents
:test-result: PASS toString on const wchar_t pointer returns the string contents
diff --git a/packages/Catch2/tests/SelfTest/Baselines/automake.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
index 2afd308bc4a723ce00eff68d06f6284388fc7197..cd56e6487121bd0629b83ca3f3607cfd4df6a860 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
@@ -23,6 +23,7 @@
:test-result: PASS #1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - double
:test-result: PASS #2152 - ULP checks between differently signed values were wrong - float
+:test-result: XFAIL #2615 - Throwing in constructor generator fails test case but does not abort
:test-result: XFAIL #748 - captures with unexpected exceptions
:test-result: PASS #809
:test-result: PASS #833
@@ -127,8 +128,8 @@
:test-result: FAIL Custom std-exceptions can be custom translated
:test-result: PASS Default scale is invisible to comparison
:test-result: PASS Directly creating an EnumInfo
+:test-result: SKIP Empty generators can SKIP in constructor
:test-result: PASS Empty stream name opens cout stream
-:test-result: PASS Empty tag is not allowed
:test-result: FAIL EndsWith string matcher
:test-result: PASS Enums can quickly have stringification enabled using REGISTER_ENUM
:test-result: PASS Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM
@@ -140,6 +141,7 @@
:test-result: PASS Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified
:test-result: FAIL Exception matchers that fail
:test-result: PASS Exception matchers that succeed
+:test-result: PASS Exception message can be matched
:test-result: PASS Exception messages can be tested for
:test-result: PASS Exceptions matchers
:test-result: FAIL Expected exceptions that don't throw or unexpected exceptions fail the test
@@ -147,6 +149,7 @@
:test-result: FAIL FAIL does not require an argument
:test-result: FAIL FAIL_CHECK does not abort the test
:test-result: PASS Factorials are computed
+:test-result: PASS Filter generator throws exception for empty generator
:test-result: PASS Floating point matchers: double
:test-result: PASS Floating point matchers: float
:test-result: PASS Generators -- adapters
@@ -186,7 +189,7 @@
:test-result: PASS Our PCG implementation provides expected results for known seeds
:test-result: FAIL Output from all sections is reported
:test-result: PASS Overloaded comma or address-of operators are not used
-:test-result: PASS Parse test names and tags
+:test-result: PASS Parse uints
:test-result: PASS Parsed tags are matched case insensitive
:test-result: PASS Parsing sharding-related cli flags
:test-result: PASS Parsing tags with non-alphabetical characters is pass-through
@@ -261,6 +264,7 @@
:test-result: FAIL Thrown string literals are translated
:test-result: PASS Tracker
:test-result: PASS Trim strings
+:test-result: PASS Type conversions of RangeEquals and similar
:test-result: FAIL Unexpected exceptions can be translated
:test-result: PASS Upcasting special member functions
:test-result: PASS Usage of AllMatch range matcher
@@ -269,6 +273,8 @@
:test-result: PASS Usage of AnyTrue range matcher
:test-result: PASS Usage of NoneMatch range matcher
:test-result: PASS Usage of NoneTrue range matcher
+:test-result: PASS Usage of RangeEquals range matcher
+:test-result: PASS Usage of UnorderedRangeEquals range matcher
:test-result: PASS Usage of the SizeIs range matcher
:test-result: PASS Use a custom approx
:test-result: PASS Variadic macros
@@ -289,6 +295,7 @@
:test-result: PASS X/level/1/b
:test-result: PASS XmlEncode
:test-result: PASS XmlWriter writes boolean attributes as true/false
+:test-result: SKIP a succeeding test can still be skipped
:test-result: PASS analyse no analysis
:test-result: PASS array<int, N> -> toString
:test-result: PASS benchmark function call
@@ -301,10 +308,14 @@
:test-result: PASS comparisons between const int variables
:test-result: PASS comparisons between int variables
:test-result: PASS convertToBits
+:test-result: SKIP dynamic skipping works with generators
:test-result: PASS empty tags are not allowed
:test-result: PASS erfc_inv
:test-result: PASS estimate_clock_resolution
:test-result: PASS even more nested SECTION tests
+:test-result: XFAIL failed assertions before SKIP cause test case to fail
+:test-result: XFAIL failing for some generator values causes entire test case to fail
+:test-result: XFAIL failing in some unskipped sections causes entire test case to fail
:test-result: FAIL first tag
:test-result: FAIL has printf
:test-result: PASS is_unary_function
@@ -322,6 +333,7 @@
:test-result: FAIL mix info, unscoped info and warning
:test-result: FAIL more nested SECTION tests
:test-result: PASS nested SECTION tests
+:test-result: FAIL nested sections can be skipped dynamically at runtime
:test-result: PASS non streamable - with conv. op
:test-result: PASS non-copyable objects
:test-result: PASS normal_cdf
@@ -343,9 +355,11 @@
:test-result: PASS run_for_at_least, chronometer
:test-result: PASS run_for_at_least, int
:test-result: FAIL second tag
+:test-result: SKIP sections can be skipped dynamically at runtime
:test-result: FAIL send a single char to INFO
:test-result: FAIL sends information to INFO
:test-result: PASS shortened hide tags are split apart
+:test-result: SKIP skipped tests can optionally provide a reason
:test-result: PASS splitString
:test-result: FAIL stacks unscoped info in loops
:test-result: PASS startsWith
@@ -367,6 +381,7 @@
:test-result: PASS strlen3
:test-result: PASS tables
:test-result: PASS tags with dots in later positions are not parsed as hidden
+:test-result: SKIP tests can be skipped dynamically at runtime
:test-result: FAIL thrown std::strings are translated
:test-result: PASS toString on const wchar_t const pointer returns the string contents
:test-result: PASS toString on const wchar_t pointer returns the string contents
diff --git a/packages/Catch2/tests/SelfTest/Baselines/compact.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/compact.sw.approved.txt
index 6d23d01de2d5942b83d5fe94205ab9d425db0dd2..be7a4120358629363c6bb134ec364c602de737e4 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/compact.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/compact.sw.approved.txt
@@ -1,4 +1,4 @@
-Filters: ~[!nonportable]~[!benchmark]~[approvals] *
+Filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
RNG seed: 1
Misc.tests.cpp:<line number>: passed: with 1 message: 'yay'
Compilation.tests.cpp:<line number>: passed: y.v == 0 for: 0 == 0
@@ -22,13 +22,13 @@ This would not be caught previously
Nor would this
Tricky.tests.cpp:<line number>: failed: explicitly with 1 message: '1514'
Compilation.tests.cpp:<line number>: passed: std::is_same<TypeList<int>, TypeList<int>>::value for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec . char")) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec , char")) for: true
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase(R"(spec \, char)"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec {a} char)")) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec [a] char)")) for: true
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("differs but has similar tag", "[a]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec \ char)")) for: true
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec . char")) for: true
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec , char")) for: true
+TestSpec.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase(R"(spec \, char)"))) for: !false
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec {a} char)")) for: true
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec [a] char)")) for: true
+TestSpec.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("differs but has similar tag", "[a]"))) for: !false
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec \ char)")) for: true
Generators.tests.cpp:<line number>: passed: counter < 7 for: 3 < 7
Generators.tests.cpp:<line number>: passed: counter < 7 for: 6 < 7
Generators.tests.cpp:<line number>: passed: i != j for: 1 != 3
@@ -84,6 +84,7 @@ Matchers.tests.cpp:<line number>: passed: smallest_non_zero, WithinULP( -smalles
Matchers.tests.cpp:<line number>: passed: smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-324, -0.0000000000000000e+00])
Matchers.tests.cpp:<line number>: passed: smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45])
Matchers.tests.cpp:<line number>: passed: smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00])
+Generators.tests.cpp:<line number>: failed: unexpected exception with message: 'failure to init'
Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'answer := 42' with 1 message: 'expected exception'
Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'answer := 42'; expression was: thisThrows() with 1 message: 'expected exception'
Exception.tests.cpp:<line number>: passed: thisThrows() with 1 message: 'answer := 42'
@@ -519,8 +520,8 @@ ToString.tests.cpp:<line number>: passed: enumInfo->lookup(1) == "Value2" for: V
ToString.tests.cpp:<line number>: passed: enumInfo->lookup(3) == "{** unexpected enum value **}" for: {** unexpected enum value **}
==
"{** unexpected enum value **}"
+Skip.tests.cpp:<line number>: skipped: 'This generator is empty'
Stream.tests.cpp:<line number>: passed: Catch::makeStream( "" )->isConsole() for: true
-Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
Matchers.tests.cpp:<line number>: failed: testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring"
Matchers.tests.cpp:<line number>: failed: testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: "this" (case insensitive)
EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value1 ) == "Value1" for: "Value1" == "Value1"
@@ -572,6 +573,10 @@ Matchers.tests.cpp:<line number>: failed: throwsSpecialException( 3 ), SpecialEx
Matchers.tests.cpp:<line number>: failed: throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 1 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 2 ), SpecialException, ExceptionMatcher{ 2 } for: SpecialException::what special exception has value of 2
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) ) for: DerivedException::what matches "starts with: "Derived""
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) ) for: DerivedException::what matches "ends with: "::what""
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) ) for: DerivedException::what matches "not starts with: "::what""
+Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) ) for: SpecialException::what matches "starts with: "Special""
Exception.tests.cpp:<line number>: passed: thisThrows(), "expected exception" for: "expected exception" equals: "expected exception"
Exception.tests.cpp:<line number>: passed: thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) for: "expected exception" equals: "expected exception" (case insensitive)
Exception.tests.cpp:<line number>: passed: thisThrows(), StartsWith( "expected" ) for: "expected exception" starts with: "expected"
@@ -594,6 +599,7 @@ Misc.tests.cpp:<line number>: passed: Factorial(1) == 1 for: 1 == 1
Misc.tests.cpp:<line number>: passed: Factorial(2) == 2 for: 2 == 2
Misc.tests.cpp:<line number>: passed: Factorial(3) == 6 for: 6 == 6
Misc.tests.cpp:<line number>: passed: Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+GeneratorsImpl.tests.cpp:<line number>: passed: filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
Matchers.tests.cpp:<line number>: passed: 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other
@@ -623,6 +629,7 @@ Matchers.tests.cpp:<line number>: passed: WithinULP( 1., 0 )
Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 0. )
Matchers.tests.cpp:<line number>: passed: WithinRel( 1., -0.2 ), std::domain_error
Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 1. ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: 1., !IsNaN() for: 1.0 not is NaN
Matchers.tests.cpp:<line number>: passed: 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other
@@ -655,6 +662,7 @@ Matchers.tests.cpp:<line number>: passed: WithinULP( 1.f, static_cast<uint64_t>(
Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, 0.f )
Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, -0.2f ), std::domain_error
Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, 1.f ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: 1., !IsNaN() for: 1.0 not is NaN
Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
@@ -1119,170 +1127,30 @@ Matchers.tests.cpp:<line number>: passed: ( EvilMatcher(), EvilMatcher() ), Evil
Matchers.tests.cpp:<line number>: passed: &EvilMatcher(), EvilAddressOfOperatorUsed
Matchers.tests.cpp:<line number>: passed: EvilMatcher() || ( EvilMatcher() && !EvilMatcher() )
Matchers.tests.cpp:<line number>: passed: ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher()
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "*a" ).matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "a*" ).matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "*a*" ).matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) for: true
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("only hidden", "[.]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")) for: true
+Parse.tests.cpp:<line number>: passed: parseUInt( "0" ) == Optional<unsigned int>{ 0 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: parseUInt( "100" ) == Optional<unsigned int>{ 100 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "!!KJHF*#" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "-1" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "4294967296" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "42949672964294967296429496729642949672964294967296" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "2 4" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "0x<hex digits>", 10 )) for: !{?}
TestSpecParser.tests.cpp:<line number>: passed: spec.hasFilters() for: true
TestSpecParser.tests.cpp:<line number>: passed: spec.getInvalidSpecs().empty() for: true
TestSpecParser.tests.cpp:<line number>: passed: spec.matches( testCase ) for: true
CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-count=8" }) for: {?}
CmdLine.tests.cpp:<line number>: passed: config.shardCount == 8 for: 8 == 8
CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
-CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" ) for: "Could not parse '-1' as shard count" contains: "Could not parse '-1' as shard count"
CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
-CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring( "Shard count must be positive" ) for: "Shard count must be positive" contains: "Shard count must be positive"
CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-index=2" }) for: {?}
CmdLine.tests.cpp:<line number>: passed: config.shardIndex == 2 for: 2 == 2
CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
-CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number") for: "Shard index must be a non-negative number" contains: "Shard index must be a non-negative number"
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" ) for: "Could not parse '-12' as shard index" contains: "Could not parse '-12' as shard index"
CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-index=0" }) for: {?}
CmdLine.tests.cpp:<line number>: passed: config.shardIndex == 0 for: 0 == 0
TestSpecParser.tests.cpp:<line number>: passed: spec.hasFilters() for: true with 1 message: 'tagString := "[tag with spaces]"'
@@ -1995,6 +1863,23 @@ There is no extra whitespace here
StringManip.tests.cpp:<line number>: passed: trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here
==
There is no extra whitespace here
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
+MatchersRanges.tests.cpp:<line number>: passed: a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
@@ -2100,6 +1985,38 @@ MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+MatchersRanges.tests.cpp:<line number>: passed: mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked1.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: mocked1, RangeEquals( arr ) for: { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: { } has size == 0
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: { } not has size == 2
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: { } size matches is less than 2
@@ -2196,6 +2113,8 @@ Xml.tests.cpp:<line number>: passed: encode( "[\x7F]" ) == "[\\x7F]" for: "[\x7F
Xml.tests.cpp:<line number>: passed: stream.str(), ContainsSubstring(R"(attr1="true")") && ContainsSubstring(R"(attr2="false")") for: "<?xml version="1.0" encoding="UTF-8"?>
<Element1 attr1="true" attr2="false"/>
" ( contains: "attr1="true"" and contains: "attr2="false"" )
+Skip.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: skipped:
InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.point.count() == 23 for: 23.0 == 23
InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.lower_bound.count() == 23 for: 23.0 == 23
InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.upper_bound.count() == 23 for: 23.0 == 23
@@ -2285,6 +2204,9 @@ FloatingPoint.tests.cpp:<line number>: passed: convertToBits( -0. ) == ( 1ULL <<
9223372036854775808 (0x<hex digits>)
FloatingPoint.tests.cpp:<line number>: passed: convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 for: 1 == 1
FloatingPoint.tests.cpp:<line number>: passed: convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 for: 1 == 1
+Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 41'
+Skip.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 43'
Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 )
InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 )
@@ -2294,6 +2216,14 @@ InternalBenchmark.tests.cpp:<line number>: passed: res.outliers.total() == 0 for
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: failed: 3 == 4
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: failed: explicitly
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: failed: explicitly
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: failed: explicitly
loose text artifact
Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary1)>::value'
Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary2)>::value'
@@ -2351,6 +2281,10 @@ Misc.tests.cpp:<line number>: passed: a < b for: 1 < 2
Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
Misc.tests.cpp:<line number>: passed: b != a for: 2 != 1
Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
+a!
+b1!
+Skip.tests.cpp:<line number>: skipped:
+!
Tricky.tests.cpp:<line number>: passed: s == "7" for: "7" == "7"
Tricky.tests.cpp:<line number>: passed: ti == typeid(int) for: {?} == {?}
InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 )
@@ -2435,9 +2369,13 @@ InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 128 >= 64
InternalBenchmark.tests.cpp:<line number>: passed: Timing.elapsed >= time for: 128 ns >= 100 ns
InternalBenchmark.tests.cpp:<line number>: passed: Timing.result == Timing.iterations + 17 for: 145 == 145
InternalBenchmark.tests.cpp:<line number>: passed: Timing.iterations >= time.count() for: 128 >= 100
+Skip.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: failed: false with 1 message: '3'
Message.tests.cpp:<line number>: failed: false with 2 messages: 'hi' and 'i := 7'
Tag.tests.cpp:<line number>: passed: testcase.tags, VectorContains( Tag( "magic-tag" ) ) && VectorContains( Tag( "."_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} and Contains: {?} )
+Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 43'
StringManip.tests.cpp:<line number>: passed: splitStringRef("", ','), Equals(std::vector<StringRef>()) for: { } Equals: { }
StringManip.tests.cpp:<line number>: passed: splitStringRef("abc", ','), Equals(std::vector<StringRef>{"abc"}) for: { abc } Equals: { abc }
StringManip.tests.cpp:<line number>: passed: splitStringRef("abc,def", ','), Equals(std::vector<StringRef>{"abc", "def"}) for: { abc, def } Equals: { abc, def }
@@ -2503,6 +2441,7 @@ Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_
Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 6 == 6
Tag.tests.cpp:<line number>: passed: testcase.tags.size() == 1 for: 1 == 1
Tag.tests.cpp:<line number>: passed: testcase.tags[0].original == "magic.tag"_catch_sr for: magic.tag == magic.tag
+Skip.tests.cpp:<line number>: skipped:
Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'Why would you throw a std::string?'
Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
@@ -2599,5 +2538,7 @@ InternalBenchmark.tests.cpp:<line number>: passed: med == 18. for: 18.0 == 18.0
InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
-Failed 83 test cases, failed 143 assertions.
+test cases: 409 | 308 passed | 84 failed | 6 skipped | 11 failed as expected
+assertions: 2225 | 2048 passed | 145 failed | 32 failed as expected
+
diff --git a/packages/Catch2/tests/SelfTest/Baselines/compact.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
index a3500a352d5d15e9548f7c92be723e5b00ffd66b..6c48ab917fb8b1d1aba40105e3d4c58c8bb14cd7 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
@@ -1,4 +1,4 @@
-Filters: ~[!nonportable]~[!benchmark]~[approvals] *
+Filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
RNG seed: 1
Misc.tests.cpp:<line number>: passed: with 1 message: 'yay'
Compilation.tests.cpp:<line number>: passed: y.v == 0 for: 0 == 0
@@ -20,13 +20,13 @@ This info message starts with a linebreak' with 1 message: '
This warning message starts with a linebreak'
Tricky.tests.cpp:<line number>: failed: explicitly with 1 message: '1514'
Compilation.tests.cpp:<line number>: passed: std::is_same<TypeList<int>, TypeList<int>>::value for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec . char")) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec , char")) for: true
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase(R"(spec \, char)"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec {a} char)")) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec [a] char)")) for: true
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("differs but has similar tag", "[a]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec \ char)")) for: true
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec . char")) for: true
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("spec , char")) for: true
+TestSpec.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase(R"(spec \, char)"))) for: !false
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec {a} char)")) for: true
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec [a] char)")) for: true
+TestSpec.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("differs but has similar tag", "[a]"))) for: !false
+TestSpec.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase(R"(spec \ char)")) for: true
Generators.tests.cpp:<line number>: passed: counter < 7 for: 3 < 7
Generators.tests.cpp:<line number>: passed: counter < 7 for: 6 < 7
Generators.tests.cpp:<line number>: passed: i != j for: 1 != 3
@@ -82,6 +82,7 @@ Matchers.tests.cpp:<line number>: passed: smallest_non_zero, WithinULP( -smalles
Matchers.tests.cpp:<line number>: passed: smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-324, -0.0000000000000000e+00])
Matchers.tests.cpp:<line number>: passed: smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45])
Matchers.tests.cpp:<line number>: passed: smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00])
+Generators.tests.cpp:<line number>: failed: unexpected exception with message: 'failure to init'
Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'answer := 42' with 1 message: 'expected exception'
Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'answer := 42'; expression was: thisThrows() with 1 message: 'expected exception'
Exception.tests.cpp:<line number>: passed: thisThrows() with 1 message: 'answer := 42'
@@ -517,8 +518,8 @@ ToString.tests.cpp:<line number>: passed: enumInfo->lookup(1) == "Value2" for: V
ToString.tests.cpp:<line number>: passed: enumInfo->lookup(3) == "{** unexpected enum value **}" for: {** unexpected enum value **}
==
"{** unexpected enum value **}"
+Skip.tests.cpp:<line number>: skipped: 'This generator is empty'
Stream.tests.cpp:<line number>: passed: Catch::makeStream( "" )->isConsole() for: true
-Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
Matchers.tests.cpp:<line number>: failed: testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring"
Matchers.tests.cpp:<line number>: failed: testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) for: "this string contains 'abc' as a substring" ends with: "this" (case insensitive)
EnumToString.tests.cpp:<line number>: passed: stringify( EnumClass3::Value1 ) == "Value1" for: "Value1" == "Value1"
@@ -570,6 +571,10 @@ Matchers.tests.cpp:<line number>: failed: throwsSpecialException( 3 ), SpecialEx
Matchers.tests.cpp:<line number>: failed: throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 1 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 2 ), SpecialException, ExceptionMatcher{ 2 } for: SpecialException::what special exception has value of 2
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) ) for: DerivedException::what matches "starts with: "Derived""
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) ) for: DerivedException::what matches "ends with: "::what""
+Matchers.tests.cpp:<line number>: passed: throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) ) for: DerivedException::what matches "not starts with: "::what""
+Matchers.tests.cpp:<line number>: passed: throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) ) for: SpecialException::what matches "starts with: "Special""
Exception.tests.cpp:<line number>: passed: thisThrows(), "expected exception" for: "expected exception" equals: "expected exception"
Exception.tests.cpp:<line number>: passed: thisThrows(), Equals( "expecteD Exception", Catch::CaseSensitive::No ) for: "expected exception" equals: "expected exception" (case insensitive)
Exception.tests.cpp:<line number>: passed: thisThrows(), StartsWith( "expected" ) for: "expected exception" starts with: "expected"
@@ -592,6 +597,7 @@ Misc.tests.cpp:<line number>: passed: Factorial(1) == 1 for: 1 == 1
Misc.tests.cpp:<line number>: passed: Factorial(2) == 2 for: 2 == 2
Misc.tests.cpp:<line number>: passed: Factorial(3) == 6 for: 6 == 6
Misc.tests.cpp:<line number>: passed: Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+GeneratorsImpl.tests.cpp:<line number>: passed: filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
Matchers.tests.cpp:<line number>: passed: 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 10., !WithinRel( 11.2, 0.1 ) for: 10.0 not and 11.2 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 1., !WithinRel( 0., 0.99 ) for: 1.0 not and 0 are within 99% of each other
@@ -621,6 +627,7 @@ Matchers.tests.cpp:<line number>: passed: WithinULP( 1., 0 )
Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 0. )
Matchers.tests.cpp:<line number>: passed: WithinRel( 1., -0.2 ), std::domain_error
Matchers.tests.cpp:<line number>: passed: WithinRel( 1., 1. ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: 1., !IsNaN() for: 1.0 not is NaN
Matchers.tests.cpp:<line number>: passed: 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 10.f, !WithinRel( 11.2f, 0.1f ) for: 10.0f not and 11.2 are within 10% of each other
Matchers.tests.cpp:<line number>: passed: 1.f, !WithinRel( 0.f, 0.99f ) for: 1.0f not and 0 are within 99% of each other
@@ -653,6 +660,7 @@ Matchers.tests.cpp:<line number>: passed: WithinULP( 1.f, static_cast<uint64_t>(
Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, 0.f )
Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, -0.2f ), std::domain_error
Matchers.tests.cpp:<line number>: passed: WithinRel( 1.f, 1.f ), std::domain_error
+Matchers.tests.cpp:<line number>: passed: 1., !IsNaN() for: 1.0 not is NaN
Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
Generators.tests.cpp:<line number>: passed: i % 2 == 0 for: 0 == 0
@@ -1117,170 +1125,30 @@ Matchers.tests.cpp:<line number>: passed: ( EvilMatcher(), EvilMatcher() ), Evil
Matchers.tests.cpp:<line number>: passed: &EvilMatcher(), EvilAddressOfOperatorUsed
Matchers.tests.cpp:<line number>: passed: EvilMatcher() || ( EvilMatcher() && !EvilMatcher() )
Matchers.tests.cpp:<line number>: passed: ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher()
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "*a" ).matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "a*" ).matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: parseTestSpec( "*a*" ).matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.hasFilters() == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcA ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcB ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcC ) == false for: false == false
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *tcD ) == true for: true == true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) for: true
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: !(spec.matches(*fakeTestCase("only hidden", "[.]"))) for: !false
-CmdLine.tests.cpp:<line number>: passed: spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")) for: true
+Parse.tests.cpp:<line number>: passed: parseUInt( "0" ) == Optional<unsigned int>{ 0 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: parseUInt( "100" ) == Optional<unsigned int>{ 100 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 } for: {?} == {?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "!!KJHF*#" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "-1" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "4294967296" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "42949672964294967296429496729642949672964294967296" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "2 4" )) for: !{?}
+Parse.tests.cpp:<line number>: passed: !(parseUInt( "0x<hex digits>", 10 )) for: !{?}
TestSpecParser.tests.cpp:<line number>: passed: spec.hasFilters() for: true
TestSpecParser.tests.cpp:<line number>: passed: spec.getInvalidSpecs().empty() for: true
TestSpecParser.tests.cpp:<line number>: passed: spec.matches( testCase ) for: true
CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-count=8" }) for: {?}
CmdLine.tests.cpp:<line number>: passed: config.shardCount == 8 for: 8 == 8
CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
-CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" ) for: "Could not parse '-1' as shard count" contains: "Could not parse '-1' as shard count"
CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
-CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring( "Shard count must be positive" ) for: "Shard count must be positive" contains: "Shard count must be positive"
CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-index=2" }) for: {?}
CmdLine.tests.cpp:<line number>: passed: config.shardIndex == 2 for: 2 == 2
CmdLine.tests.cpp:<line number>: passed: !(result) for: !{?}
-CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number") for: "Shard index must be a non-negative number" contains: "Shard index must be a non-negative number"
+CmdLine.tests.cpp:<line number>: passed: result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" ) for: "Could not parse '-12' as shard index" contains: "Could not parse '-12' as shard index"
CmdLine.tests.cpp:<line number>: passed: cli.parse({ "test", "--shard-index=0" }) for: {?}
CmdLine.tests.cpp:<line number>: passed: config.shardIndex == 0 for: 0 == 0
TestSpecParser.tests.cpp:<line number>: passed: spec.hasFilters() for: true with 1 message: 'tagString := "[tag with spaces]"'
@@ -1988,6 +1856,23 @@ There is no extra whitespace here
StringManip.tests.cpp:<line number>: passed: trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here
==
There is no extra whitespace here
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
+MatchersRanges.tests.cpp:<line number>: passed: a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
Exception.tests.cpp:<line number>: failed: unexpected exception with message: '3.14'
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
UniquePtr.tests.cpp:<line number>: passed: bptr->i == 3 for: 3 == 3
@@ -2093,6 +1978,38 @@ MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+MatchersRanges.tests.cpp:<line number>: passed: mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked1.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: mocked1, RangeEquals( arr ) for: { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked1.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
+MatchersRanges.tests.cpp:<line number>: passed: non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
+MatchersRanges.tests.cpp:<line number>: passed: vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
+MatchersRanges.tests.cpp:<line number>: passed: needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: { } has size == 0
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: { } not has size == 2
MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: { } size matches is less than 2
@@ -2189,6 +2106,8 @@ Xml.tests.cpp:<line number>: passed: encode( "[\x7F]" ) == "[\\x7F]" for: "[\x7F
Xml.tests.cpp:<line number>: passed: stream.str(), ContainsSubstring(R"(attr1="true")") && ContainsSubstring(R"(attr2="false")") for: "<?xml version="1.0" encoding="UTF-8"?>
<Element1 attr1="true" attr2="false"/>
" ( contains: "attr1="true"" and contains: "attr2="false"" )
+Skip.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: skipped:
InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.point.count() == 23 for: 23.0 == 23
InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.lower_bound.count() == 23 for: 23.0 == 23
InternalBenchmark.tests.cpp:<line number>: passed: analysis.mean.upper_bound.count() == 23 for: 23.0 == 23
@@ -2278,6 +2197,9 @@ FloatingPoint.tests.cpp:<line number>: passed: convertToBits( -0. ) == ( 1ULL <<
9223372036854775808 (0x<hex digits>)
FloatingPoint.tests.cpp:<line number>: passed: convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 for: 1 == 1
FloatingPoint.tests.cpp:<line number>: passed: convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 for: 1 == 1
+Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 41'
+Skip.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 43'
Tag.tests.cpp:<line number>: passed: Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.103560) == Approx(-0.09203687623843015) for: -0.0920368762 == Approx( -0.0920368762 )
InternalBenchmark.tests.cpp:<line number>: passed: erfc_inv(1.067400) == Approx(-0.05980291115763361) for: -0.0598029112 == Approx( -0.0598029112 )
@@ -2287,6 +2209,14 @@ InternalBenchmark.tests.cpp:<line number>: passed: res.outliers.total() == 0 for
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: failed: 3 == 4
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: failed: explicitly
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: failed: explicitly
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: failed: explicitly
Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary1)>::value'
Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary2)>::value'
Clara.tests.cpp:<line number>: passed: with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary3)>::value'
@@ -2343,6 +2273,7 @@ Misc.tests.cpp:<line number>: passed: a < b for: 1 < 2
Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
Misc.tests.cpp:<line number>: passed: b != a for: 2 != 1
Misc.tests.cpp:<line number>: passed: a != b for: 1 != 2
+Skip.tests.cpp:<line number>: skipped:
Tricky.tests.cpp:<line number>: passed: s == "7" for: "7" == "7"
Tricky.tests.cpp:<line number>: passed: ti == typeid(int) for: {?} == {?}
InternalBenchmark.tests.cpp:<line number>: passed: normal_cdf(0.000000) == Approx(0.50000000000000000) for: 0.5 == Approx( 0.5 )
@@ -2427,9 +2358,13 @@ InternalBenchmark.tests.cpp:<line number>: passed: x >= old_x for: 128 >= 64
InternalBenchmark.tests.cpp:<line number>: passed: Timing.elapsed >= time for: 128 ns >= 100 ns
InternalBenchmark.tests.cpp:<line number>: passed: Timing.result == Timing.iterations + 17 for: 145 == 145
InternalBenchmark.tests.cpp:<line number>: passed: Timing.iterations >= time.count() for: 128 >= 100
+Skip.tests.cpp:<line number>: passed:
+Skip.tests.cpp:<line number>: skipped:
+Skip.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: failed: false with 1 message: '3'
Message.tests.cpp:<line number>: failed: false with 2 messages: 'hi' and 'i := 7'
Tag.tests.cpp:<line number>: passed: testcase.tags, VectorContains( Tag( "magic-tag" ) ) && VectorContains( Tag( "."_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} and Contains: {?} )
+Skip.tests.cpp:<line number>: skipped: 'skipping because answer = 43'
StringManip.tests.cpp:<line number>: passed: splitStringRef("", ','), Equals(std::vector<StringRef>()) for: { } Equals: { }
StringManip.tests.cpp:<line number>: passed: splitStringRef("abc", ','), Equals(std::vector<StringRef>{"abc"}) for: { abc } Equals: { abc }
StringManip.tests.cpp:<line number>: passed: splitStringRef("abc,def", ','), Equals(std::vector<StringRef>{"abc", "def"}) for: { abc, def } Equals: { abc, def }
@@ -2495,6 +2430,7 @@ Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_
Generators.tests.cpp:<line number>: passed: strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(data)) for: 6 == 6
Tag.tests.cpp:<line number>: passed: testcase.tags.size() == 1 for: 1 == 1
Tag.tests.cpp:<line number>: passed: testcase.tags[0].original == "magic.tag"_catch_sr for: magic.tag == magic.tag
+Skip.tests.cpp:<line number>: skipped:
Exception.tests.cpp:<line number>: failed: unexpected exception with message: 'Why would you throw a std::string?'
Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
Misc.tests.cpp:<line number>: passed: result == "\"wide load\"" for: ""wide load"" == ""wide load""
@@ -2591,5 +2527,7 @@ InternalBenchmark.tests.cpp:<line number>: passed: med == 18. for: 18.0 == 18.0
InternalBenchmark.tests.cpp:<line number>: passed: q3 == 23. for: 23.0 == 23.0
Misc.tests.cpp:<line number>: passed:
Misc.tests.cpp:<line number>: passed:
-Failed 83 test cases, failed 143 assertions.
+test cases: 409 | 308 passed | 84 failed | 6 skipped | 11 failed as expected
+assertions: 2225 | 2048 passed | 145 failed | 32 failed as expected
+
diff --git a/packages/Catch2/tests/SelfTest/Baselines/console.std.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/console.std.approved.txt
index 6962e50826101c2e9d072f04c20170c8ea9b1a9f..0945f0dfb8c4f4dda4ba9b5dbb46eadc43cdb671 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/console.std.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/console.std.approved.txt
@@ -1,4 +1,4 @@
-Filters: ~[!nonportable]~[!benchmark]~[approvals] *
+Filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
Randomness seeded to: 1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -27,6 +27,16 @@ Tricky.tests.cpp:<line number>: FAILED:
explicitly with message:
1514
+-------------------------------------------------------------------------------
+#2615 - Throwing in constructor generator fails test case but does not abort
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ failure to init
+
-------------------------------------------------------------------------------
#748 - captures with unexpected exceptions
outside assertions
@@ -373,6 +383,16 @@ Exception.tests.cpp:<line number>: FAILED:
due to unexpected exception with message:
custom std exception
+-------------------------------------------------------------------------------
+Empty generators can SKIP in constructor
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ This generator is empty
+
-------------------------------------------------------------------------------
EndsWith string matcher
-------------------------------------------------------------------------------
@@ -1164,6 +1184,14 @@ Exception.tests.cpp:<line number>: FAILED:
due to unexpected exception with message:
unexpected exception
+-------------------------------------------------------------------------------
+a succeeding test can still be skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
checkedElse, failing
-------------------------------------------------------------------------------
@@ -1186,6 +1214,87 @@ Misc.tests.cpp:<line number>: FAILED:
with expansion:
false
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 41
+
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 43
+
+-------------------------------------------------------------------------------
+failed assertions before SKIP cause test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+ CHECK( 3 == 4 )
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing in some unskipped sections causes entire test case to fail
+ skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing in some unskipped sections causes entire test case to fail
+ not skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
loose text artifact
-------------------------------------------------------------------------------
just failure
@@ -1304,6 +1413,19 @@ Misc.tests.cpp:<line number>: FAILED:
with expansion:
1 == 2
+a!
+b1!
+-------------------------------------------------------------------------------
+nested sections can be skipped dynamically at runtime
+ B
+ B2
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+!
-------------------------------------------------------------------------------
not prints unscoped info from previous failures
-------------------------------------------------------------------------------
@@ -1338,6 +1460,15 @@ Message.tests.cpp:<line number>: FAILED:
with message:
this SHOULD be seen only ONCE
+-------------------------------------------------------------------------------
+sections can be skipped dynamically at runtime
+ skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
send a single char to INFO
-------------------------------------------------------------------------------
@@ -1361,6 +1492,16 @@ with messages:
hi
i := 7
+-------------------------------------------------------------------------------
+skipped tests can optionally provide a reason
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 43
+
-------------------------------------------------------------------------------
stacks unscoped info in loops
-------------------------------------------------------------------------------
@@ -1383,6 +1524,14 @@ with messages:
5
6
+-------------------------------------------------------------------------------
+tests can be skipped dynamically at runtime
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
thrown std::strings are translated
-------------------------------------------------------------------------------
@@ -1394,6 +1543,6 @@ due to unexpected exception with message:
Why would you throw a std::string?
===============================================================================
-test cases: 394 | 318 passed | 69 failed | 7 failed as expected
-assertions: 2284 | 2129 passed | 128 failed | 27 failed as expected
+test cases: 409 | 322 passed | 69 failed | 7 skipped | 11 failed as expected
+assertions: 2208 | 2048 passed | 128 failed | 32 failed as expected
diff --git a/packages/Catch2/tests/SelfTest/Baselines/console.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/console.sw.approved.txt
index 63dd231e89388f1ff7507f579243d648913cf245..150980e82ff902f791fec3ee357653d1a67b6c07 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/console.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/console.sw.approved.txt
@@ -1,4 +1,4 @@
-Filters: ~[!nonportable]~[!benchmark]~[approvals] *
+Filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
Randomness seeded to: 1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -166,20 +166,20 @@ with expansion:
-------------------------------------------------------------------------------
#1905 -- test spec parser properly clears internal state between compound tests
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase("spec . char")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase("spec , char")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( spec.matches(*fakeTestCase(R"(spec \, char)")) )
with expansion:
!false
@@ -188,20 +188,20 @@ with expansion:
#1912 -- test spec parser handles escaping
Various parentheses
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec {a} char)")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec [a] char)")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( spec.matches(*fakeTestCase("differs but has similar tag", "[a]")) )
with expansion:
!false
@@ -210,10 +210,10 @@ with expansion:
#1912 -- test spec parser handles escaping
backslash in test name
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec \ char)")) )
with expansion:
true
@@ -761,6 +761,16 @@ with expansion:
0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.
00000000e+00])
+-------------------------------------------------------------------------------
+#2615 - Throwing in constructor generator fails test case but does not abort
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ failure to init
+
-------------------------------------------------------------------------------
#748 - captures with unexpected exceptions
outside assertions
@@ -3946,6 +3956,16 @@ with expansion:
==
"{** unexpected enum value **}"
+-------------------------------------------------------------------------------
+Empty generators can SKIP in constructor
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ This generator is empty
+
-------------------------------------------------------------------------------
Empty stream name opens cout stream
-------------------------------------------------------------------------------
@@ -3957,15 +3977,6 @@ Stream.tests.cpp:<line number>: PASSED:
with expansion:
true
--------------------------------------------------------------------------------
-Empty tag is not allowed
--------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
-...............................................................................
-
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE_THROWS( Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo ) )
-
-------------------------------------------------------------------------------
EndsWith string matcher
-------------------------------------------------------------------------------
@@ -4282,6 +4293,32 @@ Matchers.tests.cpp:<line number>: PASSED:
with expansion:
SpecialException::what special exception has value of 2
+-------------------------------------------------------------------------------
+Exception message can be matched
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) ) )
+with expansion:
+ DerivedException::what matches "starts with: "Derived""
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) ) )
+with expansion:
+ DerivedException::what matches "ends with: "::what""
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) ) )
+with expansion:
+ DerivedException::what matches "not starts with: "::what""
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) ) )
+with expansion:
+ SpecialException::what matches "starts with: "Special""
+
-------------------------------------------------------------------------------
Exception messages can be tested for
exact match
@@ -4441,6 +4478,15 @@ Misc.tests.cpp:<line number>: PASSED:
with expansion:
3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+-------------------------------------------------------------------------------
+Filter generator throws exception for empty generator
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_AS( filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException )
+
-------------------------------------------------------------------------------
Floating point matchers: double
Relative
@@ -4626,6 +4672,18 @@ Matchers.tests.cpp:<line number>: PASSED:
Matchers.tests.cpp:<line number>: PASSED:
REQUIRE_THROWS_AS( WithinRel( 1., 1. ), std::domain_error )
+-------------------------------------------------------------------------------
+Floating point matchers: double
+ IsNaN
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( 1., !IsNaN() )
+with expansion:
+ 1.0 not is NaN
+
-------------------------------------------------------------------------------
Floating point matchers: float
Relative
@@ -4819,6 +4877,18 @@ Matchers.tests.cpp:<line number>: PASSED:
Matchers.tests.cpp:<line number>: PASSED:
REQUIRE_THROWS_AS( WithinRel( 1.f, 1.f ), std::domain_error )
+-------------------------------------------------------------------------------
+Floating point matchers: float
+ IsNaN
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( 1., !IsNaN() )
+with expansion:
+ 1.0 not is NaN
+
-------------------------------------------------------------------------------
Generators -- adapters
Filtering by predicate
@@ -8056,2170 +8126,1238 @@ Matchers.tests.cpp:<line number>: PASSED:
REQUIRE_NOTHROW( ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher() )
-------------------------------------------------------------------------------
-Parse test names and tags
- Empty test spec should have no filters
+Parse uints
+ proper inputs
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Parse.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "0" ) == Optional<unsigned int>{ 0 } )
with expansion:
- false == false
+ {?} == {?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "100" ) == Optional<unsigned int>{ 100 } )
with expansion:
- false == false
+ {?} == {?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 } )
with expansion:
- false == false
+ {?} == {?}
+
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 } )
+with expansion:
+ {?} == {?}
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from empty string should have no filters
+Parse uints
+ Bad inputs
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Parse.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "!!KJHF*#" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "-1" ) )
with expansion:
- false == false
+ !{?}
--------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from just a comma should have no filters
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "4294967296" ) )
+with expansion:
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "42949672964294967296429496729642949672964294967296" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "2 4" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "0x<hex digits>", 10 ) )
with expansion:
- false == false
+ !{?}
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from name should have one filter
+Parsed tags are matched case insensitive
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpecParser.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.hasFilters() )
with expansion:
- true == true
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.getInvalidSpecs().empty() )
with expansion:
- false == false
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.matches( testCase ) )
with expansion:
- true == true
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from quoted name should have one filter
+Parsing sharding-related cli flags
+ shard-count
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( cli.parse({ "test", "--shard-count=8" }) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ REQUIRE( config.shardCount == 8 )
with expansion:
- true == true
+ 8 == 8
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from name should have one filter
+Parsing sharding-related cli flags
+ Negative shard count reports error
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK_FALSE( result )
with expansion:
- true == true
+ !{?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" ) )
with expansion:
- false == false
+ "Could not parse '-1' as shard count" contains: "Could not parse '-1' as
+ shard count"
+
+-------------------------------------------------------------------------------
+Parsing sharding-related cli flags
+ Zero shard count reports error
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK_FALSE( result )
with expansion:
- true == true
+ !{?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring( "Shard count must be positive" ) )
with expansion:
- false == false
+ "Shard count must be positive" contains: "Shard count must be positive"
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at the start
+Parsing sharding-related cli flags
+ shard-index
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( cli.parse({ "test", "--shard-index=2" }) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( config.shardIndex == 2 )
with expansion:
- false == false
+ 2 == 2
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Parsing sharding-related cli flags
+ Negative shard index reports error
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ CHECK_FALSE( result )
with expansion:
- false == false
+ !{?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( parseTestSpec( "*a" ).matches( *tcA ) == true )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" ) )
with expansion:
- true == true
+ "Could not parse '-12' as shard index" contains: "Could not parse '-12' as
+ shard index"
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at the end
+Parsing sharding-related cli flags
+ Shard index 0 is accepted
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({ "test", "--shard-index=0" }) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.shardIndex == 0 )
with expansion:
- false == false
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Parsing tags with non-alphabetical characters is pass-through
+-------------------------------------------------------------------------------
+TestSpecParser.tests.cpp:<line number>
+...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.hasFilters() )
with expansion:
- true == true
+ true
+with message:
+ tagString := "[tag with spaces]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.getInvalidSpecs().empty() )
with expansion:
- false == false
+ true
+with message:
+ tagString := "[tag with spaces]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( parseTestSpec( "a*" ).matches( *tcA ) == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.matches( testCase ) )
with expansion:
- true == true
+ true
+with message:
+ tagString := "[tag with spaces]"
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at both ends
+Parsing tags with non-alphabetical characters is pass-through
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpecParser.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.hasFilters() )
with expansion:
- true == true
+ true
+with message:
+ tagString := "[I said "good day" sir!]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.getInvalidSpecs().empty() )
with expansion:
- false == false
+ true
+with message:
+ tagString := "[I said "good day" sir!]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.matches( testCase ) )
with expansion:
- false == false
+ true
+with message:
+ tagString := "[I said "good day" sir!]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Parsing warnings
+ NoAssertions
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( cli.parse( { "test", "-w", "NoAssertions" } ) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( parseTestSpec( "*a*" ).matches( *tcA ) == true )
+ REQUIRE( config.warnings == WarnAbout::NoAssertions )
with expansion:
- true == true
+ 1 == 1
-------------------------------------------------------------------------------
-Parse test names and tags
- Redundant wildcard at the start
+Parsing warnings
+ NoTests is no longer supported
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ REQUIRE_FALSE( cli.parse( { "test", "-w", "NoTests" } ) )
with expansion:
- true == true
+ !{?}
+
+-------------------------------------------------------------------------------
+Parsing warnings
+ Combining multiple warnings
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( cli.parse( { "test", "--warn", "NoAssertions", "--warn", "UnmatchedTestSpec" } ) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) )
with expansion:
- false == false
+ 3 == 3
-------------------------------------------------------------------------------
-Parse test names and tags
- Redundant wildcard at the end
+Pointers can be compared to null
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Condition.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( p == 0 )
with expansion:
- true == true
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( p == pNULL )
with expansion:
- true == true
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( p != 0 )
with expansion:
- false == false
+ 0x<hex digits> != 0
--------------------------------------------------------------------------------
-Parse test names and tags
- Redundant wildcard at both ends
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( cp != 0 )
+with expansion:
+ 0x<hex digits> != 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( cpc != 0 )
with expansion:
- true == true
+ 0x<hex digits> != 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( returnsNull() == 0 )
with expansion:
- true == true
+ {null string} == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( returnsConstNull() == 0 )
with expansion:
- false == false
+ {null string} == 0
+
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( 0 != p )
+with expansion:
+ 0 != 0x<hex digits>
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at both ends, redundant at start
+Precision of floating point stringification can be set
+ Floats
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+ToStringGeneral.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ CHECK( str1.size() == 3 + 5 )
with expansion:
- true == true
+ 8 == 8
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( str2.size() == 3 + 10 )
with expansion:
- false == false
+ 13 == 13
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Precision of floating point stringification can be set
+ Double
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ CHECK( str1.size() == 2 + 5 )
with expansion:
- true == true
+ 7 == 7
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( str2.size() == 2 + 15 )
with expansion:
- true == true
+ 17 == 17
-------------------------------------------------------------------------------
-Parse test names and tags
- Just wildcard
+Predicate matcher can accept const char*
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Matchers.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( "foo", Predicate<const char*>( []( const char* const& ) { return true; } ) )
with expansion:
- true == true
+ "foo" matches undescribed predicate
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ empty args don't cause a crash
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ CHECK( config.processName == "" )
with expansion:
- true == true
+ "" == ""
-------------------------------------------------------------------------------
-Parse test names and tags
- Single tag
+Process can be configured on command line
+ default - no arguments
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( result )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( config.processName == "test" )
with expansion:
- true == true
+ "test" == "test"
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( config.shouldDebugBreak == false )
with expansion:
false == false
--------------------------------------------------------------------------------
-Parse test names and tags
- Single tag, two matches
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( config.abortAfter == -1 )
with expansion:
- true == true
+ -1 == -1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( config.noThrow == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( config.reporterSpecifications.empty() )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK_FALSE( cfg.hasTestFilters() )
with expansion:
- true == true
-
--------------------------------------------------------------------------------
-Parse test names and tags
- Two tags
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+ !false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cfg.getReporterSpecs().size() == 1 )
with expansion:
- true == true
+ 1 == 1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( cfg.getReporterSpecs()[0] == Catch::ReporterSpec{ expectedReporter, {}, {}, {} } )
with expansion:
- false == false
+ {?} == {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ CHECK( cfg.getProcessedReporterSpecs().size() == 1 )
with expansion:
- false == false
+ 1 == 1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( cfg.getProcessedReporterSpecs()[0] == Catch::ProcessedReporterSpec{ expectedReporter, std::string{}, Catch::ColourMode::PlatformDefault, {} } )
with expansion:
- true == true
+ {?} == {?}
-------------------------------------------------------------------------------
-Parse test names and tags
- Two tags, spare separated
+Process can be configured on command line
+ test lists
+ Specify one test case using
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( cfg.hasTestFilters() )
with expansion:
- false == false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) )
with expansion:
- true == true
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcarded name and tag
+Process can be configured on command line
+ test lists
+ Specify one test case exclusion using exclude:
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( cfg.hasTestFilters() )
with expansion:
- false == false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
with expansion:
- false == false
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Single tag exclusion
+Process can be configured on command line
+ test lists
+ Specify one test case exclusion using ~
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( cfg.hasTestFilters() )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
with expansion:
- false == false
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- One tag exclusion and one tag inclusion
+Process can be configured on command line
+ reporter
+ -r/console
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", {}, {}, {} } } )
with expansion:
- false == false
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ -r/xml
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", {}, {}, {} } } )
with expansion:
- false == false
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-------------------------------------------------------------------------------
-Parse test names and tags
- One tag exclusion and one wldcarded name inclusion
+Process can be configured on command line
+ reporter
+ --reporter/junit
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "junit", {}, {}, {} } } )
with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
-with expansion:
- true == true
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-------------------------------------------------------------------------------
-Parse test names and tags
- One tag exclusion, using exclude:, and one wldcarded name inclusion
+Process can be configured on command line
+ reporter
+ must match one of the available ones
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( !result )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Unrecognized reporter") )
with expansion:
- false == false
+ "Unrecognized reporter, 'unsupported'. Check available with --list-reporters"
+ contains: "Unrecognized reporter"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ With output file
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( result )
with expansion:
- false == false
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "out.txt"s, {}, {} } } )
with expansion:
- true == true
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-------------------------------------------------------------------------------
-Parse test names and tags
- name exclusion
+Process can be configured on command line
+ reporter
+ With Windows-like absolute path as output file
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "C:\\Temp\\out.txt"s, {}, {} } } )
with expansion:
- true == true
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ Multiple reporters
+ All with output files
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "junit::out=output-junit.xml" }) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "junit", "output-junit.xml"s, {}, {} } } )
with expansion:
- true == true
+ { {?}, {?} } == { {?}, {?} }
-------------------------------------------------------------------------------
-Parse test names and tags
- wildcarded name exclusion
+Process can be configured on command line
+ reporter
+ Multiple reporters
+ Mixed output files and default output
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "console" }) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "console", {}, {}, {} } } )
with expansion:
- true == true
+ { {?}, {?} } == { {?}, {?} }
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ Multiple reporters
+ cannot have multiple reporters with default output
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( !result )
with expansion:
- false == false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file.") )
with expansion:
- false == false
+ "Only one reporter may have unspecified output file." contains: "Only one
+ reporter may have unspecified output file."
-------------------------------------------------------------------------------
-Parse test names and tags
- wildcarded name exclusion with tag inclusion
+Process can be configured on command line
+ debugger
+ -b
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( cli.parse({"test", "-b"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ REQUIRE( config.shouldDebugBreak == true )
with expansion:
true == true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
-with expansion:
- false == false
-
-------------------------------------------------------------------------------
-Parse test names and tags
- wildcarded name exclusion, using exclude:, with tag inclusion
+Process can be configured on command line
+ debugger
+ --break
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({"test", "--break"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( config.shouldDebugBreak )
with expansion:
- true == true
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ -a aborts after first failure
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( cli.parse({"test", "-a"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( config.abortAfter == 1 )
with expansion:
- false == false
+ 1 == 1
-------------------------------------------------------------------------------
-Parse test names and tags
- two wildcarded names
+Process can be configured on command line
+ abort
+ -x 2 aborts after two failures
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({"test", "-x", "2"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.abortAfter == 2 )
with expansion:
- false == false
+ 2 == 2
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ -x must be numeric
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( !result )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("convert") && ContainsSubstring("oops") )
with expansion:
- false == false
+ "Unable to convert 'oops' to destination type" ( contains: "convert" and
+ contains: "oops" )
-------------------------------------------------------------------------------
-Parse test names and tags
- empty tag
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 1 == 1
-------------------------------------------------------------------------------
-Parse test names and tags
- empty quoted name
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 2 == 2
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 3 == 3
-------------------------------------------------------------------------------
-Parse test names and tags
- quoted string followed by tag exclusion
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ invalid options are reported
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( !result )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("never") && ContainsSubstring("both") )
with expansion:
- false == false
+ "keypress argument must be one of: never, start, exit or both. 'sometimes'
+ not recognised" ( contains: "never" and contains: "both" )
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ nothrow
+ -e
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({"test", "-e"}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( config.noThrow )
with expansion:
- true == true
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Leading and trailing spaces in test spec
+Process can be configured on command line
+ nothrow
+ --nothrow
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) )
+ CHECK( cli.parse({"test", "--nothrow"}) )
with expansion:
- true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) )
+ REQUIRE( config.noThrow )
with expansion:
true
-------------------------------------------------------------------------------
-Parse test names and tags
- Leading and trailing spaces in test name
+Process can be configured on command line
+ output filename
+ -o filename
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) )
+ CHECK( cli.parse({"test", "-o", "filename.ext"}) )
with expansion:
- true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) )
+ REQUIRE( config.defaultOutputFilename == "filename.ext" )
with expansion:
- true
+ "filename.ext" == "filename.ext"
-------------------------------------------------------------------------------
-Parse test names and tags
- Shortened hide tags are split apart when parsing
+Process can be configured on command line
+ output filename
+ --out
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) )
+ CHECK( cli.parse({"test", "--out", "filename.ext"}) )
with expansion:
- true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("only foo", "[foo]")) )
+ REQUIRE( config.defaultOutputFilename == "filename.ext" )
with expansion:
- !false
+ "filename.ext" == "filename.ext"
-------------------------------------------------------------------------------
-Parse test names and tags
- Shortened hide tags also properly handle exclusion
+Process can be configured on command line
+ combinations
+ Single character flags can be combined
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) )
+ CHECK( cli.parse({"test", "-abe"}) )
with expansion:
- !false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("only foo", "[foo]")) )
+ CHECK( config.abortAfter == 1 )
with expansion:
- !false
+ 1 == 1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("only hidden", "[.]")) )
+ CHECK( config.shouldDebugBreak )
with expansion:
- !false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")) )
+ CHECK( config.noThrow == true )
with expansion:
- true
+ true == true
-------------------------------------------------------------------------------
-Parsed tags are matched case insensitive
+Process can be configured on command line
+ use-colour
+ without option
-------------------------------------------------------------------------------
-TestSpecParser.tests.cpp:<line number>
+CmdLine.tests.cpp:<line number>
...............................................................................
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.hasFilters() )
-with expansion:
- true
-
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.getInvalidSpecs().empty() )
+CmdLine.tests.cpp:<line number>: PASSED:
+ CHECK( cli.parse({"test"}) )
with expansion:
- true
+ {?}
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.matches( testCase ) )
+CmdLine.tests.cpp:<line number>: PASSED:
+ REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
with expansion:
- true
+ 0 == 0
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- shard-count
+Process can be configured on command line
+ use-colour
+ auto
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--shard-count=8" }) )
+ CHECK( cli.parse( { "test", "--colour-mode", "default" } ) )
with expansion:
{?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shardCount == 8 )
+ REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
with expansion:
- 8 == 8
+ 0 == 0
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Negative shard count reports error
+Process can be configured on command line
+ use-colour
+ yes
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( result )
+ CHECK( cli.parse({"test", "--colour-mode", "ansi"}) )
with expansion:
- !{?}
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Shard count must be a positive number") )
+ REQUIRE( config.defaultColourMode == ColourMode::ANSI )
with expansion:
- "Shard count must be a positive number" contains: "Shard count must be a
- positive number"
+ 1 == 1
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Zero shard count reports error
+Process can be configured on command line
+ use-colour
+ no
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( result )
+ CHECK( cli.parse({"test", "--colour-mode", "none"}) )
with expansion:
- !{?}
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Shard count must be a positive number") )
+ REQUIRE( config.defaultColourMode == ColourMode::None )
with expansion:
- "Shard count must be a positive number" contains: "Shard count must be a
- positive number"
+ 3 == 3
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- shard-index
+Process can be configured on command line
+ use-colour
+ error
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--shard-index=2" }) )
+ CHECK( !result )
with expansion:
- {?}
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shardIndex == 2 )
+ CHECK_THAT( result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) )
with expansion:
- 2 == 2
+ "colour mode must be one of: default, ansi, win32, or none. 'wrong' is not
+ recognised" contains: "colour mode must be one of"
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Negative shard index reports error
+Process can be configured on command line
+ Benchmark options
+ samples
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( result )
+ CHECK( cli.parse({ "test", "--benchmark-samples=200" }) )
with expansion:
- !{?}
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number") )
+ REQUIRE( config.benchmarkSamples == 200 )
with expansion:
- "Shard index must be a non-negative number" contains: "Shard index must be a
- non-negative number"
+ 200 == 200
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Shard index 0 is accepted
+Process can be configured on command line
+ Benchmark options
+ resamples
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--shard-index=0" }) )
+ CHECK( cli.parse({ "test", "--benchmark-resamples=20000" }) )
with expansion:
{?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shardIndex == 0 )
+ REQUIRE( config.benchmarkResamples == 20000 )
with expansion:
- 0 == 0
+ 20000 (0x<hex digits>) == 20000 (0x<hex digits>)
-------------------------------------------------------------------------------
-Parsing tags with non-alphabetical characters is pass-through
+Process can be configured on command line
+ Benchmark options
+ confidence-interval
-------------------------------------------------------------------------------
-TestSpecParser.tests.cpp:<line number>
+CmdLine.tests.cpp:<line number>
...............................................................................
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.hasFilters() )
-with expansion:
- true
-with message:
- tagString := "[tag with spaces]"
-
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.getInvalidSpecs().empty() )
+CmdLine.tests.cpp:<line number>: PASSED:
+ CHECK( cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) )
with expansion:
- true
-with message:
- tagString := "[tag with spaces]"
+ {?}
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.matches( testCase ) )
+CmdLine.tests.cpp:<line number>: PASSED:
+ REQUIRE( config.benchmarkConfidenceInterval == Catch::Approx(0.99) )
with expansion:
- true
-with message:
- tagString := "[tag with spaces]"
+ 0.99 == Approx( 0.99 )
-------------------------------------------------------------------------------
-Parsing tags with non-alphabetical characters is pass-through
+Process can be configured on command line
+ Benchmark options
+ no-analysis
-------------------------------------------------------------------------------
-TestSpecParser.tests.cpp:<line number>
+CmdLine.tests.cpp:<line number>
...............................................................................
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.hasFilters() )
-with expansion:
- true
-with message:
- tagString := "[I said "good day" sir!]"
-
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.getInvalidSpecs().empty() )
+CmdLine.tests.cpp:<line number>: PASSED:
+ CHECK( cli.parse({ "test", "--benchmark-no-analysis" }) )
with expansion:
- true
-with message:
- tagString := "[I said "good day" sir!]"
+ {?}
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.matches( testCase ) )
+CmdLine.tests.cpp:<line number>: PASSED:
+ REQUIRE( config.benchmarkNoAnalysis )
with expansion:
true
-with message:
- tagString := "[I said "good day" sir!]"
-------------------------------------------------------------------------------
-Parsing warnings
- NoAssertions
+Process can be configured on command line
+ Benchmark options
+ warmup-time
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cli.parse( { "test", "-w", "NoAssertions" } ) )
+ CHECK( cli.parse({ "test", "--benchmark-warmup-time=10" }) )
with expansion:
{?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.warnings == WarnAbout::NoAssertions )
+ REQUIRE( config.benchmarkWarmupTime == 10 )
with expansion:
- 1 == 1
+ 10 == 10
-------------------------------------------------------------------------------
-Parsing warnings
- NoTests is no longer supported
+Product with differing arities - std::tuple<int, double, float>
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( cli.parse( { "test", "-w", "NoTests" } ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::tuple_size<TestType>::value >= 1 )
with expansion:
- !{?}
+ 3 >= 1
-------------------------------------------------------------------------------
-Parsing warnings
- Combining multiple warnings
+Product with differing arities - std::tuple<int, double>
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cli.parse( { "test", "--warn", "NoAssertions", "--warn", "UnmatchedTestSpec" } ) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::tuple_size<TestType>::value >= 1 )
with expansion:
- 3 == 3
+ 2 >= 1
-------------------------------------------------------------------------------
-Pointers can be compared to null
+Product with differing arities - std::tuple<int>
-------------------------------------------------------------------------------
-Condition.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( p == 0 )
-with expansion:
- 0 == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( p == pNULL )
-with expansion:
- 0 == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( p != 0 )
-with expansion:
- 0x<hex digits> != 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( cp != 0 )
-with expansion:
- 0x<hex digits> != 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( cpc != 0 )
-with expansion:
- 0x<hex digits> != 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( returnsNull() == 0 )
-with expansion:
- {null string} == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( returnsConstNull() == 0 )
-with expansion:
- {null string} == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( 0 != p )
-with expansion:
- 0 != 0x<hex digits>
-
--------------------------------------------------------------------------------
-Precision of floating point stringification can be set
- Floats
--------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
-...............................................................................
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- CHECK( str1.size() == 3 + 5 )
-with expansion:
- 8 == 8
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( str2.size() == 3 + 10 )
-with expansion:
- 13 == 13
-
--------------------------------------------------------------------------------
-Precision of floating point stringification can be set
- Double
--------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
-...............................................................................
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- CHECK( str1.size() == 2 + 5 )
-with expansion:
- 7 == 7
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( str2.size() == 2 + 15 )
-with expansion:
- 17 == 17
-
--------------------------------------------------------------------------------
-Predicate matcher can accept const char*
--------------------------------------------------------------------------------
-Matchers.tests.cpp:<line number>
-...............................................................................
-
-Matchers.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( "foo", Predicate<const char*>( []( const char* const& ) { return true; } ) )
-with expansion:
- "foo" matches undescribed predicate
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- empty args don't cause a crash
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.processName == "" )
-with expansion:
- "" == ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- default - no arguments
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.processName == "test" )
-with expansion:
- "test" == "test"
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.shouldDebugBreak == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.abortAfter == -1 )
-with expansion:
- -1 == -1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.noThrow == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.reporterSpecifications.empty() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( cfg.hasTestFilters() )
-with expansion:
- !false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getReporterSpecs().size() == 1 )
-with expansion:
- 1 == 1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getReporterSpecs()[0] == Catch::ReporterSpec{ expectedReporter, {}, {}, {} } )
-with expansion:
- {?} == {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getProcessedReporterSpecs().size() == 1 )
-with expansion:
- 1 == 1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getProcessedReporterSpecs()[0] == Catch::ProcessedReporterSpec{ expectedReporter, std::string{}, Catch::ColourMode::PlatformDefault, {} } )
-with expansion:
- {?} == {?}
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- test lists
- Specify one test case using
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.hasTestFilters() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- test lists
- Specify one test case exclusion using exclude:
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.hasTestFilters() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- test lists
- Specify one test case exclusion using ~
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.hasTestFilters() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- -r/console
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", {}, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- -r/xml
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", {}, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- --reporter/junit
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "junit", {}, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- must match one of the available ones
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Unrecognized reporter") )
-with expansion:
- "Unrecognized reporter, 'unsupported'. Check available with --list-reporters"
- contains: "Unrecognized reporter"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- With output file
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "out.txt"s, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- With Windows-like absolute path as output file
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "C:\\Temp\\out.txt"s, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- Multiple reporters
- All with output files
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "junit::out=output-junit.xml" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "junit", "output-junit.xml"s, {}, {} } } )
-with expansion:
- { {?}, {?} } == { {?}, {?} }
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- Multiple reporters
- Mixed output files and default output
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "console" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "console", {}, {}, {} } } )
-with expansion:
- { {?}, {?} } == { {?}, {?} }
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- Multiple reporters
- cannot have multiple reporters with default output
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file.") )
-with expansion:
- "Only one reporter may have unspecified output file." contains: "Only one
- reporter may have unspecified output file."
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- debugger
- -b
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-b"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shouldDebugBreak == true )
-with expansion:
- true == true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- debugger
- --break
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--break"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shouldDebugBreak )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- -a aborts after first failure
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-a"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.abortAfter == 1 )
-with expansion:
- 1 == 1
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- -x 2 aborts after two failures
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-x", "2"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.abortAfter == 2 )
-with expansion:
- 2 == 2
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- -x must be numeric
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("convert") && ContainsSubstring("oops") )
-with expansion:
- "Unable to convert 'oops' to destination type" ( contains: "convert" and
- contains: "oops" )
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 1 == 1
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 2 == 2
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 3 == 3
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- invalid options are reported
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("never") && ContainsSubstring("both") )
-with expansion:
- "keypress argument must be one of: never, start, exit or both. 'sometimes'
- not recognised" ( contains: "never" and contains: "both" )
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- nothrow
- -e
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-e"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.noThrow )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- nothrow
- --nothrow
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--nothrow"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.noThrow )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- output filename
- -o filename
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-o", "filename.ext"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultOutputFilename == "filename.ext" )
-with expansion:
- "filename.ext" == "filename.ext"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- output filename
- --out
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--out", "filename.ext"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultOutputFilename == "filename.ext" )
-with expansion:
- "filename.ext" == "filename.ext"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- combinations
- Single character flags can be combined
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-abe"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.abortAfter == 1 )
-with expansion:
- 1 == 1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.shouldDebugBreak )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.noThrow == true )
-with expansion:
- true == true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- without option
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
-with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- auto
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse( { "test", "--colour-mode", "default" } ) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
-with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- yes
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--colour-mode", "ansi"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::ANSI )
-with expansion:
- 1 == 1
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- no
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--colour-mode", "none"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::None )
-with expansion:
- 3 == 3
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- error
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_THAT( result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) )
-with expansion:
- "colour mode must be one of: default, ansi, win32, or none. 'wrong' is not
- recognised" contains: "colour mode must be one of"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- samples
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-samples=200" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkSamples == 200 )
-with expansion:
- 200 == 200
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- resamples
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-resamples=20000" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkResamples == 20000 )
-with expansion:
- 20000 (0x<hex digits>) == 20000 (0x<hex digits>)
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- confidence-interval
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkConfidenceInterval == Catch::Approx(0.99) )
-with expansion:
- 0.99 == Approx( 0.99 )
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- no-analysis
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-no-analysis" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkNoAnalysis )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- warmup-time
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-warmup-time=10" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkWarmupTime == 10 )
-with expansion:
- 10 == 10
-
--------------------------------------------------------------------------------
-Product with differing arities - std::tuple<int, double, float>
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
-
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( std::tuple_size<TestType>::value >= 1 )
-with expansion:
- 3 >= 1
-
--------------------------------------------------------------------------------
-Product with differing arities - std::tuple<int, double>
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
-
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( std::tuple_size<TestType>::value >= 1 )
-with expansion:
- 2 >= 1
-
--------------------------------------------------------------------------------
-Product with differing arities - std::tuple<int>
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
-
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( std::tuple_size<TestType>::value >= 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::tuple_size<TestType>::value >= 1 )
with expansion:
1 >= 1
@@ -11250,893 +10388,1183 @@ Approx.tests.cpp:<line number>
Approx.tests.cpp:<line number>: PASSED:
REQUIRE( d == Approx( 1.23 ) )
with expansion:
- 1.23 == Approx( 1.23 )
+ 1.23 == Approx( 1.23 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d != Approx( 1.22 ) )
+with expansion:
+ 1.23 != Approx( 1.22 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d != Approx( 1.24 ) )
+with expansion:
+ 1.23 != Approx( 1.24 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d == 1.23_a )
+with expansion:
+ 1.23 == Approx( 1.23 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d != 1.22_a )
+with expansion:
+ 1.23 != Approx( 1.22 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( Approx( d ) == 1.23 )
+with expansion:
+ Approx( 1.23 ) == 1.23
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( Approx( d ) != 1.22 )
+with expansion:
+ Approx( 1.23 ) != 1.22
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( Approx( d ) != 1.24 )
+with expansion:
+ Approx( 1.23 ) != 1.24
+
+Message from section one
+-------------------------------------------------------------------------------
+Standard output from all sections is reported
+ one
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'one'
+
+Message from section two
+-------------------------------------------------------------------------------
+Standard output from all sections is reported
+ two
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'two'
+
+-------------------------------------------------------------------------------
+StartsWith string matcher
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "This String"
+
+Matchers.tests.cpp:<line number>: FAILED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "string" (case
+ insensitive)
+
+-------------------------------------------------------------------------------
+Static arrays are convertible to string
+ Single item
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( Catch::Detail::stringify(singular) == "{ 1 }" )
+with expansion:
+ "{ 1 }" == "{ 1 }"
+
+-------------------------------------------------------------------------------
+Static arrays are convertible to string
+ Multiple
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( Catch::Detail::stringify(arr) == "{ 3, 2, 1 }" )
+with expansion:
+ "{ 3, 2, 1 }" == "{ 3, 2, 1 }"
+
+-------------------------------------------------------------------------------
+Static arrays are convertible to string
+ Non-trivial inner items
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( Catch::Detail::stringify(arr) == R"({ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } })" )
+with expansion:
+ "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+ ==
+ "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+
+-------------------------------------------------------------------------------
+String matchers
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string" ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "string"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "string" (case
+ insensitive)
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), ContainsSubstring( "abc" ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "abc"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), ContainsSubstring( "aBC", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "abc" (case
+ insensitive)
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "this" ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "this"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "THIS", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "this" (case
+ insensitive)
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) )
+with expansion:
+ "this string contains 'abc' as a substring" ends with: "substring"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), EndsWith( " SuBsTrInG", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" ends with: " substring" (case
+ insensitive)
+
+-------------------------------------------------------------------------------
+StringRef
+ Empty string
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( empty.empty() )
+with expansion:
+ true
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( empty.size() == 0 )
+with expansion:
+ 0 == 0
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp( empty.data(), "" ) == 0 )
+with expansion:
+ 0 == 0
+
+-------------------------------------------------------------------------------
+StringRef
+ From string literal
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.empty() == false )
+with expansion:
+ false == false
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.size() == 5 )
+with expansion:
+ 5 == 5
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp( rawChars, "hello" ) == 0 )
+with expansion:
+ 0 == 0
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.data() == rawChars )
+with expansion:
+ "hello" == "hello"
+
+-------------------------------------------------------------------------------
+StringRef
+ From sub-string
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( original == "original" )
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE_NOTHROW( original.data() )
+
+-------------------------------------------------------------------------------
+StringRef
+ Copy construction is shallow
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( original.begin() == copy.begin() )
+with expansion:
+ "original string" == "original string"
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d != Approx( 1.22 ) )
-with expansion:
- 1.23 != Approx( 1.22 )
+-------------------------------------------------------------------------------
+StringRef
+ Copy assignment is shallow
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d != Approx( 1.24 ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( original.begin() == copy.begin() )
with expansion:
- 1.23 != Approx( 1.24 )
+ "original string" == "original string"
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d == 1.23_a )
-with expansion:
- 1.23 == Approx( 1.23 )
+-------------------------------------------------------------------------------
+StringRef
+ Substrings
+ zero-based substring
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d != 1.22_a )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss.empty() == false )
with expansion:
- 1.23 != Approx( 1.22 )
+ false == false
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( Approx( d ) == 1.23 )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss.size() == 5 )
with expansion:
- Approx( 1.23 ) == 1.23
+ 5 == 5
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( Approx( d ) != 1.22 )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strncmp( ss.data(), "hello", 5 ) == 0 )
with expansion:
- Approx( 1.23 ) != 1.22
+ 0 == 0
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( Approx( d ) != 1.24 )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss == "hello" )
with expansion:
- Approx( 1.23 ) != 1.24
+ hello == "hello"
-Message from section one
-------------------------------------------------------------------------------
-Standard output from all sections is reported
- one
+StringRef
+ Substrings
+ non-zero-based substring
-------------------------------------------------------------------------------
-Message.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss.size() == 6 )
+with expansion:
+ 6 == 6
-No assertions in section 'one'
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp( ss.data(), "world!" ) == 0 )
+with expansion:
+ 0 == 0
-Message from section two
-------------------------------------------------------------------------------
-Standard output from all sections is reported
- two
+StringRef
+ Substrings
+ Pointer values of full refs should match
-------------------------------------------------------------------------------
-Message.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-
-No assertions in section 'two'
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.data() == s2.data() )
+with expansion:
+ "hello world!" == "hello world!"
-------------------------------------------------------------------------------
-StartsWith string matcher
+StringRef
+ Substrings
+ Pointer values of substring refs should also match
-------------------------------------------------------------------------------
-Matchers.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-Matchers.tests.cpp:<line number>: FAILED:
- CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
-with expansion:
- "this string contains 'abc' as a substring" starts with: "This String"
-
-Matchers.tests.cpp:<line number>: FAILED:
- CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.data() == ss.data() )
with expansion:
- "this string contains 'abc' as a substring" starts with: "string" (case
- insensitive)
+ "hello world!" == "hello world!"
-------------------------------------------------------------------------------
-Static arrays are convertible to string
- Single item
+StringRef
+ Substrings
+ Past the end substring
-------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( Catch::Detail::stringify(singular) == "{ 1 }" )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.substr(s.size() + 1, 123).empty() )
with expansion:
- "{ 1 }" == "{ 1 }"
+ true
-------------------------------------------------------------------------------
-Static arrays are convertible to string
- Multiple
+StringRef
+ Substrings
+ Substring off the end are trimmed
-------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( Catch::Detail::stringify(arr) == "{ 3, 2, 1 }" )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp(ss.data(), "world!") == 0 )
with expansion:
- "{ 3, 2, 1 }" == "{ 3, 2, 1 }"
+ 0 == 0
-------------------------------------------------------------------------------
-Static arrays are convertible to string
- Non-trivial inner items
+StringRef
+ Substrings
+ substring start after the end is empty
-------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( Catch::Detail::stringify(arr) == R"({ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } })" )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.substr(1'000'000, 1).empty() )
with expansion:
- "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
- ==
- "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+ true
-------------------------------------------------------------------------------
-String matchers
+StringRef
+ Comparisons are deep
-------------------------------------------------------------------------------
-Matchers.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-Matchers.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string" ) )
+String.tests.cpp:<line number>: PASSED:
+ CHECK( reinterpret_cast<char*>(buffer1) != reinterpret_cast<char*>(buffer2) )
with expansion:
- "this string contains 'abc' as a substring" contains: "string"
+ "Hello" != "Hello"
-Matchers.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( left == right )
with expansion:
- "this string contains 'abc' as a substring" contains: "string" (case
- insensitive)
+ Hello == Hello
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), ContainsSubstring( "abc" ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( left != left.substr(0, 3) )
with expansion:
- "this string contains 'abc' as a substring" contains: "abc"
+ Hello != Hel
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), ContainsSubstring( "aBC", Catch::CaseSensitive::No ) )
-with expansion:
- "this string contains 'abc' as a substring" contains: "abc" (case
- insensitive)
+-------------------------------------------------------------------------------
+StringRef
+ from std::string
+ implicitly constructed
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), StartsWith( "this" ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr == "a standard string" )
with expansion:
- "this string contains 'abc' as a substring" starts with: "this"
+ a standard string == "a standard string"
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), StartsWith( "THIS", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr.size() == stdStr.size() )
with expansion:
- "this string contains 'abc' as a substring" starts with: "this" (case
- insensitive)
+ 17 == 17
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) )
+-------------------------------------------------------------------------------
+StringRef
+ from std::string
+ explicitly constructed
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr == "a standard string" )
with expansion:
- "this string contains 'abc' as a substring" ends with: "substring"
+ a standard string == "a standard string"
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), EndsWith( " SuBsTrInG", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr.size() == stdStr.size() )
with expansion:
- "this string contains 'abc' as a substring" ends with: " substring" (case
- insensitive)
+ 17 == 17
-------------------------------------------------------------------------------
StringRef
- Empty string
+ from std::string
+ assigned
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( empty.empty() )
-with expansion:
- true
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( empty.size() == 0 )
+ REQUIRE( sr == "a standard string" )
with expansion:
- 0 == 0
+ a standard string == "a standard string"
String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp( empty.data(), "" ) == 0 )
+ REQUIRE( sr.size() == stdStr.size() )
with expansion:
- 0 == 0
+ 17 == 17
-------------------------------------------------------------------------------
StringRef
- From string literal
+ to std::string
+ explicitly constructed
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.empty() == false )
+ REQUIRE( stdStr == "a stringref" )
with expansion:
- false == false
+ "a stringref" == "a stringref"
String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.size() == 5 )
+ REQUIRE( stdStr.size() == sr.size() )
with expansion:
- 5 == 5
+ 11 == 11
+
+-------------------------------------------------------------------------------
+StringRef
+ to std::string
+ assigned
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp( rawChars, "hello" ) == 0 )
+ REQUIRE( stdStr == "a stringref" )
with expansion:
- 0 == 0
+ "a stringref" == "a stringref"
String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.data() == rawChars )
+ REQUIRE( stdStr.size() == sr.size() )
with expansion:
- "hello" == "hello"
+ 11 == 11
-------------------------------------------------------------------------------
StringRef
- From sub-string
+ std::string += StringRef
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( original == "original" )
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE_NOTHROW( original.data() )
+ REQUIRE( lhs == "some string += the stringref contents" )
+with expansion:
+ "some string += the stringref contents"
+ ==
+ "some string += the stringref contents"
-------------------------------------------------------------------------------
StringRef
- Copy construction is shallow
+ StringRef + StringRef
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( original.begin() == copy.begin() )
+ REQUIRE( together == "abrakadabra" )
with expansion:
- "original string" == "original string"
+ "abrakadabra" == "abrakadabra"
-------------------------------------------------------------------------------
-StringRef
- Copy assignment is shallow
+StringRef at compilation time
+ Simple constructors
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( original.begin() == copy.begin() )
-with expansion:
- "original string" == "original string"
+with message:
+ empty.size() == 0
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ empty.begin() == empty.end()
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.size() == 3
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.data() == abc
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.begin() == abc
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.begin() != stringref.end()
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.substr(10, 0).empty()
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.substr(2, 1).data() == abc + 2
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref[1] == 'b'
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ shortened.size() == 2
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ shortened.data() == abc
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ shortened.begin() != shortened.end()
-------------------------------------------------------------------------------
-StringRef
- Substrings
- zero-based substring
+StringRef at compilation time
+ UDL construction
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss.empty() == false )
-with expansion:
- false == false
+with message:
+ !(sr1.empty())
String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss.size() == 5 )
-with expansion:
- 5 == 5
+with message:
+ sr1.size() == 3
String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strncmp( ss.data(), "hello", 5 ) == 0 )
-with expansion:
- 0 == 0
+with message:
+ sr2.empty()
String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss == "hello" )
+with message:
+ sr2.size() == 0
+
+-------------------------------------------------------------------------------
+Stringifying char arrays with statically known sizes - char
+-------------------------------------------------------------------------------
+ToString.tests.cpp:<line number>
+...............................................................................
+
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
with expansion:
- hello == "hello"
+ ""abc"" == ""abc""
+
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+with expansion:
+ ""abc"" == ""abc""
-------------------------------------------------------------------------------
-StringRef
- Substrings
- non-zero-based substring
+Stringifying char arrays with statically known sizes - signed char
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToString.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss.size() == 6 )
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
with expansion:
- 6 == 6
+ ""abc"" == ""abc""
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp( ss.data(), "world!" ) == 0 )
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
with expansion:
- 0 == 0
+ ""abc"" == ""abc""
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Pointer values of full refs should match
+Stringifying char arrays with statically known sizes - unsigned char
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToString.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.data() == s2.data() )
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
with expansion:
- "hello world!" == "hello world!"
+ ""abc"" == ""abc""
+
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+with expansion:
+ ""abc"" == ""abc""
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Pointer values of substring refs should also match
+Stringifying std::chrono::duration helpers
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToStringChrono.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.data() == ss.data() )
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( minute == seconds )
with expansion:
- "hello world!" == "hello world!"
+ 1 m == 60 s
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( hour != seconds )
+with expansion:
+ 1 h != 60 s
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( micro != milli )
+with expansion:
+ 1 us != 1 ms
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( nano != micro )
+with expansion:
+ 1 ns != 1 us
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Past the end substring
+Stringifying std::chrono::duration with weird ratios
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToStringChrono.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.substr(s.size() + 1, 123).empty() )
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( half_minute != femto_second )
with expansion:
- true
+ 1 [30/1]s != 1 fs
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( pico_second != atto_second )
+with expansion:
+ 1 ps != 1 as
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Substring off the end are trimmed
+Stringifying std::chrono::time_point<system_clock>
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToStringChrono.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp(ss.data(), "world!") == 0 )
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( now != later )
with expansion:
- 0 == 0
+ {iso8601-timestamp}
+ !=
+ {iso8601-timestamp}
-------------------------------------------------------------------------------
-StringRef
- Substrings
- substring start after the end is empty
+Tabs and newlines show in output
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.substr(1'000'000, 1).empty() )
+Misc.tests.cpp:<line number>: FAILED:
+ CHECK( s1 == s2 )
with expansion:
- true
+ "if ($b == 10) {
+ $a = 20;
+ }"
+ ==
+ "if ($b == 10) {
+ $a = 20;
+ }
+ "
-------------------------------------------------------------------------------
-StringRef
- Comparisons are deep
+Tag alias can be registered against tag patterns
+ The same tag alias can only be registered once
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- CHECK( reinterpret_cast<char*>(buffer1) != reinterpret_cast<char*>(buffer2) )
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "[@zzz]" ) )
with expansion:
- "Hello" != "Hello"
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "[@zzz]"
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( left == right )
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "file" ) )
with expansion:
- Hello == Hello
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "file"
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( left != left.substr(0, 3) )
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "2" ) )
with expansion:
- Hello != Hel
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "2"
+
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "10" ) )
+with expansion:
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "10"
-------------------------------------------------------------------------------
-StringRef
- from std::string
- implicitly constructed
+Tag alias can be registered against tag patterns
+ Tag aliases must be of the form [@name]
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr == "a standard string" )
-with expansion:
- a standard string == "a standard string"
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "[no ampersat]", "", Catch::SourceLineInfo( "file", 3 ) ) )
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr.size() == stdStr.size() )
-with expansion:
- 17 == 17
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "[the @ is not at the start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
+
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "@no square bracket at start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
+
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) ) )
-------------------------------------------------------------------------------
-StringRef
- from std::string
- explicitly constructed
+Tags with spaces and non-alphanumerical characters are accepted
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr == "a standard string" )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.tags.size() == 2 )
with expansion:
- a standard string == "a standard string"
+ 2 == 2
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr.size() == stdStr.size() )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( testCase.tags, VectorContains( Tag( "tag with spaces" ) ) && VectorContains( Tag( "I said \"good day\" sir!"_catch_sr ) ) )
with expansion:
- 17 == 17
+ { {?}, {?} } ( Contains: {?} and Contains: {?} )
-------------------------------------------------------------------------------
-StringRef
- from std::string
- assigned
+Template test case method with test types specified inside std::tuple - MyTypes
+- 0
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Class.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr == "a standard string" )
-with expansion:
- a standard string == "a standard string"
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr.size() == stdStr.size() )
+Class.tests.cpp:<line number>: PASSED:
+ REQUIRE( Template_Fixture<TestType>::m_a == 1 )
with expansion:
- 17 == 17
+ 1 == 1
-------------------------------------------------------------------------------
-StringRef
- to std::string
- explicitly constructed
+Template test case method with test types specified inside std::tuple - MyTypes
+- 1
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Class.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr == "a stringref" )
-with expansion:
- "a stringref" == "a stringref"
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr.size() == sr.size() )
+Class.tests.cpp:<line number>: PASSED:
+ REQUIRE( Template_Fixture<TestType>::m_a == 1 )
with expansion:
- 11 == 11
+ 1 == 1
-------------------------------------------------------------------------------
-StringRef
- to std::string
- assigned
+Template test case method with test types specified inside std::tuple - MyTypes
+- 2
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Class.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr == "a stringref" )
-with expansion:
- "a stringref" == "a stringref"
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr.size() == sr.size() )
+Class.tests.cpp:<line number>: PASSED:
+ REQUIRE( Template_Fixture<TestType>::m_a == 1 )
with expansion:
- 11 == 11
+ 1.0 == 1
-------------------------------------------------------------------------------
-StringRef
- std::string += StringRef
+Template test case with test types specified inside non-copyable and non-
+movable std::tuple - NonCopyableAndNonMovableTypes - 0
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( lhs == "some string += the stringref contents" )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- "some string += the stringref contents"
- ==
- "some string += the stringref contents"
+ 1 > 0
-------------------------------------------------------------------------------
-StringRef
- StringRef + StringRef
+Template test case with test types specified inside non-copyable and non-
+movable std::tuple - NonCopyableAndNonMovableTypes - 1
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( together == "abrakadabra" )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- "abrakadabra" == "abrakadabra"
+ 4 > 0
-------------------------------------------------------------------------------
-StringRef at compilation time
- Simple constructors
+Template test case with test types specified inside non-default-constructible
+std::tuple - MyNonDefaultConstructibleTypes - 0
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
-with message:
- empty.size() == 0
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- empty.begin() == empty.end()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.size() == 3
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.data() == abc
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.begin() == abc
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.begin() != stringref.end()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.substr(10, 0).empty()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.substr(2, 1).data() == abc + 2
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref[1] == 'b'
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- shortened.size() == 2
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- shortened.data() == abc
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- shortened.begin() != shortened.end()
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
+with expansion:
+ 1 > 0
-------------------------------------------------------------------------------
-StringRef at compilation time
- UDL construction
+Template test case with test types specified inside non-default-constructible
+std::tuple - MyNonDefaultConstructibleTypes - 1
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
-with message:
- !(sr1.empty())
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- sr1.size() == 3
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- sr2.empty()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- sr2.size() == 0
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
+with expansion:
+ 4 > 0
-------------------------------------------------------------------------------
-Stringifying char arrays with statically known sizes - char
+Template test case with test types specified inside std::tuple - MyTypes - 0
-------------------------------------------------------------------------------
-ToString.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
-with expansion:
- ""abc"" == ""abc""
-
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- ""abc"" == ""abc""
+ 4 > 0
-------------------------------------------------------------------------------
-Stringifying char arrays with statically known sizes - signed char
+Template test case with test types specified inside std::tuple - MyTypes - 1
-------------------------------------------------------------------------------
-ToString.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
-with expansion:
- ""abc"" == ""abc""
-
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- ""abc"" == ""abc""
+ 1 > 0
-------------------------------------------------------------------------------
-Stringifying char arrays with statically known sizes - unsigned char
+Template test case with test types specified inside std::tuple - MyTypes - 2
-------------------------------------------------------------------------------
-ToString.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
-with expansion:
- ""abc"" == ""abc""
-
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- ""abc"" == ""abc""
+ 4 > 0
-------------------------------------------------------------------------------
-Stringifying std::chrono::duration helpers
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-ToStringChrono.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( minute == seconds )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 m == 60 s
+ 5 == 5
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( hour != seconds )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- 1 h != 60 s
+ 5 >= 5
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( micro != milli )
+-------------------------------------------------------------------------------
+TemplateTest: vectors can be sized and resized - float
+ resizing bigger changes size and capacity
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 10 )
with expansion:
- 1 us != 1 ms
+ 10 == 10
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( nano != micro )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
with expansion:
- 1 ns != 1 us
+ 10 >= 10
-------------------------------------------------------------------------------
-Stringifying std::chrono::duration with weird ratios
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-ToStringChrono.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( half_minute != femto_second )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 [30/1]s != 1 fs
+ 5 == 5
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( pico_second != atto_second )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- 1 ps != 1 as
+ 5 >= 5
-------------------------------------------------------------------------------
-Stringifying std::chrono::time_point<system_clock>
+TemplateTest: vectors can be sized and resized - float
+ resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
-ToStringChrono.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( now != later )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 0 )
with expansion:
- {iso8601-timestamp}
- !=
- {iso8601-timestamp}
+ 0 == 0
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Tabs and newlines show in output
+TemplateTest: vectors can be sized and resized - float
+ resizing smaller changes size but not capacity
+ We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: FAILED:
- CHECK( s1 == s2 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() == 0 )
with expansion:
- "if ($b == 10) {
- $a = 20;
- }"
- ==
- "if ($b == 10) {
- $a = 20;
- }
- "
+ 0 == 0
-------------------------------------------------------------------------------
-Tag alias can be registered against tag patterns
- The same tag alias can only be registered once
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "[@zzz]" ) )
-with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "[@zzz]"
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "file" ) )
-with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "file"
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "2" ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "2"
+ 5 == 5
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "10" ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "10"
+ 5 >= 5
-------------------------------------------------------------------------------
-Tag alias can be registered against tag patterns
- Tag aliases must be of the form [@name]
+TemplateTest: vectors can be sized and resized - float
+ reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "[no ampersat]", "", Catch::SourceLineInfo( "file", 3 ) ) )
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "[the @ is not at the start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "@no square bracket at start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
+with expansion:
+ 5 == 5
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
+with expansion:
+ 10 >= 10
-------------------------------------------------------------------------------
-Tags with spaces and non-alphanumerical characters are accepted
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.tags.size() == 2 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 2 == 2
+ 5 == 5
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( testCase.tags, VectorContains( Tag( "tag with spaces" ) ) && VectorContains( Tag( "I said \"good day\" sir!"_catch_sr ) ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- { {?}, {?} } ( Contains: {?} and Contains: {?} )
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case method with test types specified inside std::tuple - MyTypes
-- 0
+TemplateTest: vectors can be sized and resized - float
+ reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
-Class.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Class.tests.cpp:<line number>: PASSED:
- REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 == 1
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case method with test types specified inside std::tuple - MyTypes
-- 1
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
-Class.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Class.tests.cpp:<line number>: PASSED:
- REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 == 1
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case method with test types specified inside std::tuple - MyTypes
-- 2
+TemplateTest: vectors can be sized and resized - int
+ resizing bigger changes size and capacity
-------------------------------------------------------------------------------
-Class.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Class.tests.cpp:<line number>: PASSED:
- REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 10 )
with expansion:
- 1.0 == 1
+ 10 == 10
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
+with expansion:
+ 10 >= 10
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-copyable and non-
-movable std::tuple - NonCopyableAndNonMovableTypes - 0
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-copyable and non-
-movable std::tuple - NonCopyableAndNonMovableTypes - 1
+TemplateTest: vectors can be sized and resized - int
+ resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 0 )
with expansion:
- 4 > 0
+ 0 == 0
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-default-constructible
-std::tuple - MyNonDefaultConstructibleTypes - 0
+TemplateTest: vectors can be sized and resized - int
+ resizing smaller changes size but not capacity
+ We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.capacity() == 0 )
with expansion:
- 1 > 0
+ 0 == 0
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-default-constructible
-std::tuple - MyNonDefaultConstructibleTypes - 1
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 4 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside std::tuple - MyTypes - 0
+TemplateTest: vectors can be sized and resized - int
+ reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 4 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
+with expansion:
+ 10 >= 10
-------------------------------------------------------------------------------
-Template test case with test types specified inside std::tuple - MyTypes - 1
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside std::tuple - MyTypes - 2
+TemplateTest: vectors can be sized and resized - int
+ reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 4 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12152,7 +11580,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12169,7 +11597,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12185,7 +11613,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12202,7 +11630,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12215,7 +11643,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12231,7 +11659,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12248,7 +11676,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12264,7 +11692,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12281,7 +11709,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12297,7 +11725,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12314,7 +11742,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12330,7 +11758,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12347,7 +11775,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12360,7 +11788,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12376,7 +11804,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12393,7 +11821,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12409,7 +11837,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12426,56 +11854,56 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 10 )
+ REQUIRE( v.size() == 2 * V )
with expansion:
- 10 == 10
+ 12 == 12
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 12 >= 12
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12487,12 +11915,12 @@ with expansion:
0 == 0
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12505,122 +11933,122 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 12 >= 12
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 10 )
+ REQUIRE( v.size() == 2 * V )
with expansion:
- 10 == 10
+ 8 == 8
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 8 >= 8
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12632,12 +12060,12 @@ with expansion:
0 == 0
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12650,73 +12078,73 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 8 >= 8
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12724,15 +12152,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12741,15 +12169,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == 2 * V )
with expansion:
- 12 == 12
+ 10 == 10
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 12 >= 12
+ 10 >= 10
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12757,15 +12185,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12779,10 +12207,10 @@ with expansion:
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12795,7 +12223,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12803,15 +12231,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12820,15 +12248,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 12 >= 12
+ 10 >= 10
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12836,15 +12264,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12853,15 +12281,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12869,15 +12297,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12886,15 +12314,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == 2 * V )
with expansion:
- 8 == 8
+ 30 == 30
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 8 >= 8
+ 30 >= 30
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12902,15 +12330,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12924,10 +12352,10 @@ with expansion:
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12940,7 +12368,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12948,15 +12376,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12965,15 +12393,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 8 >= 8
+ 30 >= 30
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12981,15 +12409,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12998,527 +12426,604 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+Test case with identical tags keeps just one
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.tags.size() == 1 )
with expansion:
- 5 == 5
+ 1 == 1
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.tags[0] == Tag( "tag1" ) )
with expansion:
- 5 >= 5
+ {?} == {?}
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- resizing bigger changes size and capacity
+Test case with one argument
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+VariadicMacros.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 2 * V )
-with expansion:
- 10 == 10
+VariadicMacros.tests.cpp:<line number>: PASSED:
+with message:
+ no assertions
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+-------------------------------------------------------------------------------
+Test enum bit values
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+ REQUIRE( 0x<hex digits> == bit30and31 )
with expansion:
- 10 >= 10
+ 3221225472 (0x<hex digits>) == 3221225472
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+Test with special, characters "in name
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+Testing checked-if
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
-with expansion:
- 5 == 5
+ CHECKED_IF( true )
+
+Misc.tests.cpp:<line number>: PASSED:
+
+Misc.tests.cpp:<line number>: FAILED - but was ok:
+ CHECKED_IF( false )
+
+Misc.tests.cpp:<line number>: PASSED:
+ CHECKED_ELSE( true )
+
+Misc.tests.cpp:<line number>: FAILED - but was ok:
+ CHECKED_ELSE( false )
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- resizing smaller changes size but not capacity
+Testing checked-if 2
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 0 )
-with expansion:
- 0 == 0
+ CHECKED_IF( true )
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
+Misc.tests.cpp:<line number>: FAILED:
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- resizing smaller changes size but not capacity
- We can use the 'swap trick' to reset the capacity
+Testing checked-if 3
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() == 0 )
-with expansion:
- 0 == 0
+Misc.tests.cpp:<line number>: FAILED - but was ok:
+ CHECKED_ELSE( false )
+
+Misc.tests.cpp:<line number>: FAILED:
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+The NO_FAIL macro reports a failure but does not fail the test
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Message.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
-with expansion:
- 5 == 5
+Message.tests.cpp:<line number>: FAILED - but was ok:
+ CHECK_NOFAIL( 1 == 2 )
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
+
+No assertions in test case 'The NO_FAIL macro reports a failure but does not fail the test'
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- reserving bigger changes capacity but not size
+The default listing implementation write to provided stream
+ Listing tags
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Reporters.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring("[fakeTag]"s) )
with expansion:
- 5 == 5
+ "All available tags:
+ 1 [fakeTag]
+ 1 tag
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+" contains: "[fakeTag]"
+
+-------------------------------------------------------------------------------
+The default listing implementation write to provided stream
+ Listing reporters
+-------------------------------------------------------------------------------
+Reporters.tests.cpp:<line number>
+...............................................................................
+
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring( "fake reporter"s ) && ContainsSubstring( "fake description"s ) )
with expansion:
- 10 >= 10
+ "Available reporters:
+ fake reporter: fake description
+
+" ( contains: "fake reporter" and contains: "fake description" )
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+The default listing implementation write to provided stream
+ Listing tests
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Reporters.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) )
with expansion:
- 5 == 5
+ "All available test cases:
+ fake test name
+ [fakeTestTag]
+ 1 test case
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+" ( contains: "fake test name" and contains: "fakeTestTag" )
+
+-------------------------------------------------------------------------------
+The default listing implementation write to provided stream
+ Listing listeners
+-------------------------------------------------------------------------------
+Reporters.tests.cpp:<line number>
+...............................................................................
+
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring( "fakeListener"s ) && ContainsSubstring( "fake description"s ) )
with expansion:
- 5 >= 5
+ "Registered listeners:
+ fakeListener: fake description
+
+" ( contains: "fakeListener" and contains: "fake description" )
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- reserving smaller does not change size or capacity
+This test 'should' fail but doesn't
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
-with expansion:
- 5 == 5
+with message:
+ oops!
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
+-------------------------------------------------------------------------------
+Thrown string literals are translated
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ For some reason someone is throwing a string literal!
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
+Tracker
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- resizing bigger changes size and capacity
+Tracker
+ successfully close one section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 2 * V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isSuccessfullyCompleted() )
with expansion:
- 30 == 30
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
with expansion:
- 30 >= 30
-
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+ false == false
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- resizing smaller changes size but not capacity
+Tracker
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 0 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- 0 == 0
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- resizing smaller changes size but not capacity
- We can use the 'swap trick' to reset the capacity
+Tracker
+ fail one section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() == 0 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isComplete() )
with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isSuccessfullyCompleted() == false )
with expansion:
- 15 == 15
+ false == false
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
with expansion:
- 15 >= 15
-
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- reserving bigger changes capacity but not size
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+ false == false
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() == false )
with expansion:
- 30 >= 30
+ false == false
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
+Tracker
+ fail one section
+ re-enter after failed section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isOpen() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1b.isOpen() == false )
with expansion:
- 15 >= 15
+ false == false
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- reserving smaller does not change size or capacity
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-Test case with identical tags keeps just one
+Tracker
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.tags.size() == 1 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- 1 == 1
+ true
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.tags[0] == Tag( "tag1" ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
with expansion:
- {?} == {?}
+ true
-------------------------------------------------------------------------------
-Test case with one argument
+Tracker
+ fail one section
-------------------------------------------------------------------------------
-VariadicMacros.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-VariadicMacros.tests.cpp:<line number>: PASSED:
-with message:
- no assertions
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isComplete() )
+with expansion:
+ true
--------------------------------------------------------------------------------
-Test enum bit values
--------------------------------------------------------------------------------
-Tricky.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isSuccessfullyCompleted() == false )
+with expansion:
+ false == false
-Tricky.tests.cpp:<line number>: PASSED:
- REQUIRE( 0x<hex digits> == bit30and31 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
with expansion:
- 3221225472 (0x<hex digits>) == 3221225472
+ false == false
--------------------------------------------------------------------------------
-Test with special, characters "in name
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
+with expansion:
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
-Testing checked-if
+Tracker
+ fail one section
+ re-enter after failed section and find next section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- CHECKED_IF( true )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isOpen() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1b.isOpen() == false )
+with expansion:
+ false == false
-Misc.tests.cpp:<line number>: FAILED - but was ok:
- CHECKED_IF( false )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2.isOpen() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
- CHECKED_ELSE( true )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: FAILED - but was ok:
- CHECKED_ELSE( false )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-Testing checked-if 2
+Tracker
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- CHECKED_IF( true )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: FAILED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-Testing checked-if 3
+Tracker
+ successfully close one section, then find another
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: FAILED - but was ok:
- CHECKED_ELSE( false )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2.isOpen() == false )
+with expansion:
+ false == false
-Misc.tests.cpp:<line number>: FAILED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
-The NO_FAIL macro reports a failure but does not fail the test
+Tracker
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
-------------------------------------------------------------------------------
-Message.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Message.tests.cpp:<line number>: FAILED - but was ok:
- CHECK_NOFAIL( 1 == 2 )
-
-
-No assertions in test case 'The NO_FAIL macro reports a failure but does not fail the test'
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isOpen() )
+with expansion:
+ true
--------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing tags
--------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1b.isOpen() == false )
+with expansion:
+ false == false
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring("[fakeTag]"s) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isOpen() )
with expansion:
- "All available tags:
- 1 [fakeTag]
- 1 tag
+ true
-" contains: "[fakeTag]"
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing reporters
+Tracker
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
+ Successfully close S2
-------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring( "fake reporter"s ) && ContainsSubstring( "fake description"s ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
with expansion:
- "Available reporters:
- fake reporter: fake description
-
-" ( contains: "fake reporter" and contains: "fake description" )
+ true
--------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing tests
--------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isSuccessfullyCompleted() )
+with expansion:
+ true
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isComplete() == false )
with expansion:
- "All available test cases:
- fake test name
- [fakeTestTag]
- 1 test case
+ false == false
-" ( contains: "fake test name" and contains: "fakeTestTag" )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isSuccessfullyCompleted() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing listeners
+Tracker
-------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring( "fakeListener"s ) && ContainsSubstring( "fake description"s ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- "Registered listeners:
- fakeListener: fake description
+ true
-" ( contains: "fakeListener" and contains: "fake description" )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-This test 'should' fail but doesn't
+Tracker
+ successfully close one section, then find another
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
-with message:
- oops!
-
--------------------------------------------------------------------------------
-Thrown string literals are translated
--------------------------------------------------------------------------------
-Exception.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2.isOpen() == false )
+with expansion:
+ false == false
-Exception.tests.cpp:<line number>: FAILED:
-due to unexpected exception with message:
- For some reason someone is throwing a string literal!
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
Tracker
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
-------------------------------------------------------------------------------
PartTracker.tests.cpp:<line number>
...............................................................................
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+ REQUIRE( testCase2.isOpen() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+ REQUIRE( s1b.isOpen() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isOpen() )
with expansion:
true
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() == false )
+with expansion:
+ false == false
+
-------------------------------------------------------------------------------
Tracker
- successfully close one section
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
+ fail S2
-------------------------------------------------------------------------------
PartTracker.tests.cpp:<line number>
...............................................................................
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isSuccessfullyCompleted() )
+ REQUIRE( ctx.completedCycle() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+ REQUIRE( s2b.isComplete() )
+with expansion:
+ true
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isSuccessfullyCompleted() == false )
with expansion:
false == false
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+ REQUIRE( testCase2.isSuccessfullyCompleted() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase3.isOpen() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() )
+ REQUIRE( s1c.isOpen() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2c.isOpen() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase3.isSuccessfullyCompleted() )
with expansion:
true
@@ -13540,538 +13045,594 @@ with expansion:
-------------------------------------------------------------------------------
Tracker
- fail one section
+ open a nested section
-------------------------------------------------------------------------------
PartTracker.tests.cpp:<line number>
...............................................................................
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() )
+ REQUIRE( s2.isOpen() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isSuccessfullyCompleted() == false )
+ REQUIRE( s2.isComplete() )
with expansion:
- false == false
+ true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+ REQUIRE( s1.isComplete() == false )
with expansion:
false == false
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+ REQUIRE( s1.isComplete() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() == false )
+ REQUIRE( testCase.isComplete() == false )
with expansion:
false == false
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() )
+with expansion:
+ true
+
-------------------------------------------------------------------------------
-Tracker
- fail one section
- re-enter after failed section
+Trim strings
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+StringManip.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(no_whitespace)) == no_whitespace )
with expansion:
- true
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(leading_whitespace)) == no_whitespace )
+with expansion:
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
+
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(trailing_whitespace)) == no_whitespace )
+with expansion:
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
+
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(whitespace_at_both_ends)) == no_whitespace )
+with expansion:
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
+
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(no_whitespace)) == StringRef(no_whitespace) )
with expansion:
- false == false
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(leading_whitespace)) == StringRef(no_whitespace) )
with expansion:
- true
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) )
with expansion:
- true
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) )
with expansion:
- true
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-------------------------------------------------------------------------------
-Tracker
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers of different container types
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, RangeEquals( c_array ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( c_array ) )
with expansion:
- true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Tracker
- fail one section
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers of different container types (differ in array N)
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_3, !RangeEquals( array_int_4 ) )
with expansion:
- true
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isSuccessfullyCompleted() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_3, !UnorderedRangeEquals( array_int_4 ) )
with expansion:
- false == false
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers of different container types and value types
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, RangeEquals( vector_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
- false == false
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Tracker
- fail one section
- re-enter after failed section and find next section
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers, one random access, one not
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
-with expansion:
- true
+MatchersRanges.tests.cpp:<line number>: PASSED:
+with message:
+ ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess(
+ list_char_a )
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, RangeEquals( list_char_a ) )
with expansion:
- false == false
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( list_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Type conversions of RangeEquals and similar
+ Value type
+ Two equal containers of different value types
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, RangeEquals( vector_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Tracker
+Type conversions of RangeEquals and similar
+ Value type
+ Two non-equal containers of different value types
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, !RangeEquals( vector_char_b ) )
with expansion:
- true
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, !UnorderedRangeEquals( vector_char_b ) )
with expansion:
- true
+ { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
+Type conversions of RangeEquals and similar
+ Ranges with begin that needs ADL
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( a, !RangeEquals( b ) )
with expansion:
- false == false
+ { 1, 2, 3 } not elements are { 3, 2, 1 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( a, UnorderedRangeEquals( b ) )
with expansion:
- false == false
+ { 1, 2, 3 } unordered elements are { 3, 2, 1 }
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
+Type conversions of RangeEquals and similar
+ Custom predicate
+ Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_a, RangeEquals( array_a_plus_1, close_enough ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) )
with expansion:
- false == false
+ { 1, 2, 3 } unordered elements are { 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isOpen() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Unexpected exceptions can be translated
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() == false )
-with expansion:
- false == false
+Exception.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ 3.14
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
- Successfully close S2
+Upcasting special member functions
+ Move constructor
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+UniquePtr.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
-with expansion:
- true
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isSuccessfullyCompleted() )
+UniquePtr.tests.cpp:<line number>: PASSED:
+ REQUIRE( bptr->i == 3 )
with expansion:
- true
+ 3 == 3
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isComplete() == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Upcasting special member functions
+ move assignment
+-------------------------------------------------------------------------------
+UniquePtr.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isSuccessfullyCompleted() )
+UniquePtr.tests.cpp:<line number>: PASSED:
+ REQUIRE( bptr->i == 3 )
with expansion:
- true
+ 3 == 3
-------------------------------------------------------------------------------
-Tracker
+Usage of AllMatch range matcher
+ Basic usage
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllMatch(SizeIs(5)) )
with expansion:
- true
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
+ }, { 1, 0, 0, -1, 5 } } all match has size == 5
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllMatch(Contains(0) && Contains(1)) )
with expansion:
- true
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
+ }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains
+ element 1 )
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
+Usage of AllMatch range matcher
+ Type requires ADL found begin and end
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() == false )
-with expansion:
- false == false
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( needs_adl, AllMatch( Predicate<int>( []( int elem ) { return elem < 6; } ) ) )
with expansion:
- false == false
+ { 1, 2, 3, 4, 5 } all match matches undescribed predicate
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
+Usage of AllMatch range matcher
+ Shortcircuiting
+ All are read
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, allMatch )
+with expansion:
+ { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
- false == false
+ true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
+with expansion:
+ true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[3] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[4] )
with expansion:
- false == false
+ true
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
- fail S2
+Usage of AllMatch range matcher
+ Shortcircuiting
+ Short-circuited
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, !allMatch )
with expansion:
- true
+ { 1, 2, 3, 4, 5 } not all match matches undescribed predicate
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isComplete() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isSuccessfullyCompleted() == false )
-with expansion:
- false == false
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isSuccessfullyCompleted() == false )
-with expansion:
- false == false
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase3.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1c.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
with expansion:
- false == false
+ true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2c.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[3] )
with expansion:
- false == false
+ !false
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase3.isSuccessfullyCompleted() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[4] )
with expansion:
- true
+ !false
-------------------------------------------------------------------------------
-Tracker
+Usage of AllTrue range matcher
+ Basic usage
+ All true evaluates to true
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllTrue() )
with expansion:
- true
+ { true, true, true, true, true } contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Basic usage
+ Empty evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllTrue() )
with expansion:
- true
+ { } contains only true
-------------------------------------------------------------------------------
-Tracker
- open a nested section
+Usage of AllTrue range matcher
+ Basic usage
+ One false evaluates to false
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- true
+ { true, true, false, true, true } not contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isComplete() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Basic usage
+ All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- false == false
+ { false, false, false, false, false } not contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Contained type is convertible to bool
+ All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllTrue() )
with expansion:
- false == false
+ { true, true, true, true, true } contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() )
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Contained type is convertible to bool
+ One false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- true
+ { true, true, false, true, true } not contains only true
-------------------------------------------------------------------------------
-Trim strings
+Usage of AllTrue range matcher
+ Contained type is convertible to bool
+ All false evaluates to false
-------------------------------------------------------------------------------
-StringManip.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(no_whitespace)) == no_whitespace )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+ { false, false, false, false, false } not contains only true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(leading_whitespace)) == no_whitespace )
-with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Shortcircuiting
+ All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(trailing_whitespace)) == no_whitespace )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, AllTrue() )
with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+ { true, true, true, true, true } contains only true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(whitespace_at_both_ends)) == no_whitespace )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(no_whitespace)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(leading_whitespace)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[3] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[4] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-------------------------------------------------------------------------------
-Unexpected exceptions can be translated
+Usage of AllTrue range matcher
+ Shortcircuiting
+ Short-circuited
-------------------------------------------------------------------------------
-Exception.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-Exception.tests.cpp:<line number>: FAILED:
-due to unexpected exception with message:
- 3.14
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, !AllTrue() )
+with expansion:
+ { true, true, false, true, true } not contains only true
--------------------------------------------------------------------------------
-Upcasting special member functions
- Move constructor
--------------------------------------------------------------------------------
-UniquePtr.tests.cpp:<line number>
-...............................................................................
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
+with expansion:
+ true
-UniquePtr.tests.cpp:<line number>: PASSED:
- REQUIRE( bptr->i == 3 )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
- 3 == 3
+ true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
+with expansion:
+ true
--------------------------------------------------------------------------------
-Upcasting special member functions
- move assignment
--------------------------------------------------------------------------------
-UniquePtr.tests.cpp:<line number>
-...............................................................................
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+ !false
-UniquePtr.tests.cpp:<line number>: PASSED:
- REQUIRE( bptr->i == 3 )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[4] )
with expansion:
- 3 == 3
+ !false
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Basic usage
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllMatch(SizeIs(5)) )
+ REQUIRE_THAT( data, AnyMatch(SizeIs(5)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } all match has size == 5
+ }, { 1, 0, 0, -1, 5 } } any match has size == 5
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllMatch(Contains(0) && Contains(1)) )
+ REQUIRE_THAT( data, !AnyMatch(Contains(0) && Contains(10)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains
- element 1 )
+ }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains
+ element 10 )
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Type requires ADL found begin and end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( needs_adl, AllMatch( Predicate<int>( []( int elem ) { return elem < 6; } ) ) )
+ REQUIRE_THAT( needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) )
with expansion:
- { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } any match matches undescribed predicate
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14079,9 +13640,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, allMatch )
+ REQUIRE_THAT( mocked, !anyMatch )
with expansion:
- { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14109,7 +13670,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14117,9 +13678,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !allMatch )
+ REQUIRE_THAT( mocked, anyMatch )
with expansion:
- { 1, 2, 3, 4, 5 } not all match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } any match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14127,14 +13688,14 @@ with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
+ REQUIRE_FALSE( mocked.m_derefed[1] )
with expansion:
- true
+ !false
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
+ REQUIRE_FALSE( mocked.m_derefed[2] )
with expansion:
- true
+ !false
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( mocked.m_derefed[3] )
@@ -14147,7 +13708,7 @@ with expansion:
!false
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
All true evaluates to true
-------------------------------------------------------------------------------
@@ -14155,38 +13716,38 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, true, true, true } contains only true
+ { true, true, true, true, true } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
- Empty evaluates to true
+ Empty evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllTrue() )
+ REQUIRE_THAT( data, !AnyTrue() )
with expansion:
- { } contains only true
+ { } not contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
- One false evalutes to false
+ One true evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, false, true, true } not contains only true
+ { false, false, true, false, false } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
All false evaluates to false
-------------------------------------------------------------------------------
@@ -14194,12 +13755,12 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, !AnyTrue() )
with expansion:
- { false, false, false, false, false } not contains only true
+ { false, false, false, false, false } not contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Contained type is convertible to bool
All true evaluates to true
-------------------------------------------------------------------------------
@@ -14207,25 +13768,25 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, true, true, true } contains only true
+ { true, true, true, true, true } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Contained type is convertible to bool
- One false evalutes to false
+ One true evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, false, true, true } not contains only true
+ { false, false, true, false, false } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Contained type is convertible to bool
All false evaluates to false
-------------------------------------------------------------------------------
@@ -14233,12 +13794,12 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, !AnyTrue() )
with expansion:
- { false, false, false, false, false } not contains only true
+ { false, false, false, false, false } not contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14246,9 +13807,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, AllTrue() )
+ REQUIRE_THAT( mocked, AnyTrue() )
with expansion:
- { true, true, true, true, true } contains only true
+ { false, false, false, false, true } contains at least one true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14276,7 +13837,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14284,9 +13845,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !AllTrue() )
+ REQUIRE_THAT( mocked, AnyTrue() )
with expansion:
- { true, true, false, true, true } not contains only true
+ { false, false, true, true, true } contains at least one true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14314,39 +13875,39 @@ with expansion:
!false
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Basic usage
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyMatch(SizeIs(5)) )
+ REQUIRE_THAT( data, NoneMatch(SizeIs(6)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } any match has size == 5
+ }, { 1, 0, 0, -1, 5 } } none match has size == 6
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyMatch(Contains(0) && Contains(10)) )
+ REQUIRE_THAT( data, !NoneMatch(Contains(0) && Contains(1)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains
- element 10 )
+ }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains
+ element 1 )
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Type requires ADL found begin and end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) )
+ REQUIRE_THAT( needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) )
with expansion:
- { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14354,9 +13915,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !anyMatch )
+ REQUIRE_THAT( mocked, noneMatch )
with expansion:
- { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14384,7 +13945,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14392,9 +13953,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, anyMatch )
+ REQUIRE_THAT( mocked, !noneMatch )
with expansion:
- { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14422,98 +13983,98 @@ with expansion:
!false
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- All true evaluates to true
+ All true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { true, true, true, true, true } contains at least one true
+ { true, true, true, true, true } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- Empty evaluates to false
+ Empty evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyTrue() )
+ REQUIRE_THAT( data, NoneTrue() )
with expansion:
- { } not contains at least one true
+ { } contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- One true evalutes to true
+ One true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { false, false, true, false, false } contains at least one true
+ { false, false, true, false, false } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- All false evaluates to false
+ All false evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyTrue() )
+ REQUIRE_THAT( data, NoneTrue() )
with expansion:
- { false, false, false, false, false } not contains at least one true
+ { false, false, false, false, false } contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Contained type is convertible to bool
- All true evaluates to true
+ All true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { true, true, true, true, true } contains at least one true
+ { true, true, true, true, true } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Contained type is convertible to bool
- One true evalutes to true
+ One true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { false, false, true, false, false } contains at least one true
+ { false, false, true, false, false } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Contained type is convertible to bool
- All false evaluates to false
+ All false evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyTrue() )
+ REQUIRE_THAT( data, NoneTrue() )
with expansion:
- { false, false, false, false, false } not contains at least one true
+ { false, false, false, false, false } contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14521,9 +14082,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, AnyTrue() )
+ REQUIRE_THAT( mocked, NoneTrue() )
with expansion:
- { false, false, false, false, true } contains at least one true
+ { false, false, false, false, false } contains no true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14551,7 +14112,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14559,9 +14120,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, AnyTrue() )
+ REQUIRE_THAT( mocked, !NoneTrue() )
with expansion:
- { false, false, true, true, true } contains at least one true
+ { false, false, true, true, true } not contains no true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14586,282 +14147,325 @@ with expansion:
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( mocked.m_derefed[4] )
with expansion:
- !false
+ !false
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Empty container matches empty container
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( empty_vector, RangeEquals( empty_vector ) )
+with expansion:
+ { } elements are { }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Empty container does not match non-empty container
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( empty_vector, !RangeEquals( non_empty_vector ) )
+with expansion:
+ { } not elements are { 1 }
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( non_empty_vector, !RangeEquals( empty_vector ) )
+with expansion:
+ { 1 } not elements are { }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Two equal 1-length non-empty containers
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( non_empty_array, RangeEquals( non_empty_array ) )
+with expansion:
+ { 1 } elements are { 1 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Two equal-sized, equal, non-empty containers
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_a, RangeEquals( array_a ) )
+with expansion:
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Two equal-sized, non-equal, non-empty containers
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_a, !RangeEquals( array_b ) )
+with expansion:
+ { 1, 2, 3 } not elements are { 2, 2, 3 }
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_a, !RangeEquals( array_c ) )
+with expansion:
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
+Usage of RangeEquals range matcher
Basic usage
+ Two non-equal-sized, non-empty containers (with same first elements)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneMatch(SizeIs(6)) )
+ CHECK_THAT( vector_a, !RangeEquals( vector_b ) )
with expansion:
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } none match has size == 6
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Custom predicate
+ Two equal non-empty containers (close enough)
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneMatch(Contains(0) && Contains(1)) )
+ CHECK_THAT( vector_a, RangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains
- element 1 )
+ { 1, 2, 3 } elements are { 2, 3, 4 }
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
- Type requires ADL found begin and end
+Usage of RangeEquals range matcher
+ Custom predicate
+ Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) )
+ CHECK_THAT( vector_a, !RangeEquals( vector_b, close_enough ) )
with expansion:
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ { 1, 2, 3 } not elements are { 3, 3, 4 }
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
- Shortcircuiting
- All are read
+Usage of RangeEquals range matcher
+ Ranges that need ADL begin/end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, noneMatch )
+ REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl2 ) )
with expansion:
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
+ REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) )
with expansion:
- true
+ { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Check short-circuiting behaviour
+ Check short-circuits on failure
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
+ REQUIRE_THAT( mocked1, !RangeEquals( arr ) )
with expansion:
- true
+ { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
+ REQUIRE( mocked1.m_derefed[0] )
with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[3] )
+ REQUIRE( mocked1.m_derefed[1] )
with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[4] )
+ REQUIRE( mocked1.m_derefed[2] )
with expansion:
true
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked1.m_derefed[3] )
+with expansion:
+ !false
+
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
- Shortcircuiting
- Short-circuited
+Usage of RangeEquals range matcher
+ Check short-circuiting behaviour
+ All elements are checked on success
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !noneMatch )
+ REQUIRE_THAT( mocked1, RangeEquals( arr ) )
with expansion:
- { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
+ { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
+ REQUIRE( mocked1.m_derefed[0] )
with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[1] )
-with expansion:
- !false
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[2] )
+ REQUIRE( mocked1.m_derefed[1] )
with expansion:
- !false
+ true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[3] )
+ REQUIRE( mocked1.m_derefed[2] )
with expansion:
- !false
+ true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[4] )
+ REQUIRE( mocked1.m_derefed[3] )
with expansion:
- !false
+ true
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- All true evaluates to false
+ Empty container matches empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( empty_vector, UnorderedRangeEquals( empty_vector ) )
with expansion:
- { true, true, true, true, true } not contains no true
+ { } unordered elements are { }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- Empty evaluates to true
+ Empty container does not match non-empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneTrue() )
+ CHECK_THAT( empty_vector, !UnorderedRangeEquals( non_empty_vector ) )
with expansion:
- { } contains no true
+ { } not unordered elements are { 1 }
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( non_empty_vector, !UnorderedRangeEquals( empty_vector ) )
+with expansion:
+ { 1 } not unordered elements are { }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- One true evalutes to false
+ Two equal 1-length non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( non_empty_array, UnorderedRangeEquals( non_empty_array ) )
with expansion:
- { false, false, true, false, false } not contains no true
+ { 1 } unordered elements are { 1 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- All false evaluates to true
+ Two equal-sized, equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneTrue() )
+ CHECK_THAT( array_a, UnorderedRangeEquals( array_a ) )
with expansion:
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Contained type is convertible to bool
- All true evaluates to false
+Usage of UnorderedRangeEquals range matcher
+ Basic usage
+ Two equal-sized, non-equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( array_a, !UnorderedRangeEquals( array_b ) )
with expansion:
- { true, true, true, true, true } not contains no true
+ { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Contained type is convertible to bool
- One true evalutes to false
+Usage of UnorderedRangeEquals range matcher
+ Basic usage
+ Two non-equal-sized, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b ) )
with expansion:
- { false, false, true, false, false } not contains no true
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Contained type is convertible to bool
- All false evaluates to true
+Usage of UnorderedRangeEquals range matcher
+ Custom predicate
+ Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneTrue() )
+ CHECK_THAT( vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
- { false, false, false, false, false } contains no true
+ { 1, 10, 20 } unordered elements are { 11, 21, 2 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Shortcircuiting
- All are read
+Usage of UnorderedRangeEquals range matcher
+ Custom predicate
+ Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, NoneTrue() )
-with expansion:
- { false, false, false, false, false } contains no true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
+ CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b, close_enough ) )
with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[3] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[4] )
-with expansion:
- true
+ { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Shortcircuiting
- Short-circuited
+Usage of UnorderedRangeEquals range matcher
+ Ranges that need ADL begin/end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !NoneTrue() )
-with expansion:
- { false, false, true, true, true } not contains no true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[3] )
-with expansion:
- !false
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[4] )
+ REQUIRE_THAT( needs_adl1, UnorderedRangeEquals( needs_adl2 ) )
with expansion:
- !false
+ { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
-------------------------------------------------------------------------------
Usage of the SizeIs range matcher
@@ -15565,6 +15169,16 @@ with expansion:
<Element1 attr1="true" attr2="false"/>
" ( contains: "attr1="true"" and contains: "attr2="false"" )
+-------------------------------------------------------------------------------
+a succeeding test can still be skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
analyse no analysis
-------------------------------------------------------------------------------
@@ -16110,6 +15724,34 @@ FloatingPoint.tests.cpp:<line number>: PASSED:
with expansion:
1 == 1
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 41
+
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 43
+
-------------------------------------------------------------------------------
empty tags are not allowed
-------------------------------------------------------------------------------
@@ -16185,6 +15827,67 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
+-------------------------------------------------------------------------------
+failed assertions before SKIP cause test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+ CHECK( 3 == 4 )
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing in some unskipped sections causes entire test case to fail
+ skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing in some unskipped sections causes entire test case to fail
+ not skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
-------------------------------------------------------------------------------
first tag
-------------------------------------------------------------------------------
@@ -16681,6 +16384,40 @@ Misc.tests.cpp:<line number>: PASSED:
with expansion:
1 != 2
+a-------------------------------------------------------------------------------
+nested sections can be skipped dynamically at runtime
+ A
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'A'
+
+!
+b1-------------------------------------------------------------------------------
+nested sections can be skipped dynamically at runtime
+ B
+ B1
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'B1'
+
+!
+-------------------------------------------------------------------------------
+nested sections can be skipped dynamically at runtime
+ B
+ B2
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+!
-------------------------------------------------------------------------------
non streamable - with conv. op
-------------------------------------------------------------------------------
@@ -17282,6 +17019,33 @@ Misc.tests.cpp:<line number>
No assertions in test case 'second tag'
+-------------------------------------------------------------------------------
+sections can be skipped dynamically at runtime
+ not skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+sections can be skipped dynamically at runtime
+ skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+sections can be skipped dynamically at runtime
+ also not skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
-------------------------------------------------------------------------------
send a single char to INFO
-------------------------------------------------------------------------------
@@ -17316,6 +17080,16 @@ Tag.tests.cpp:<line number>: PASSED:
with expansion:
{ {?}, {?} } ( Contains: {?} and Contains: {?} )
+-------------------------------------------------------------------------------
+skipped tests can optionally provide a reason
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 43
+
-------------------------------------------------------------------------------
splitString
-------------------------------------------------------------------------------
@@ -17743,6 +17517,14 @@ Tag.tests.cpp:<line number>: PASSED:
with expansion:
magic.tag == magic.tag
+-------------------------------------------------------------------------------
+tests can be skipped dynamically at runtime
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
thrown std::strings are translated
-------------------------------------------------------------------------------
@@ -18450,6 +18232,6 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
===============================================================================
-test cases: 394 | 304 passed | 83 failed | 7 failed as expected
-assertions: 2299 | 2129 passed | 143 failed | 27 failed as expected
+test cases: 409 | 308 passed | 84 failed | 6 skipped | 11 failed as expected
+assertions: 2225 | 2048 passed | 145 failed | 32 failed as expected
diff --git a/packages/Catch2/tests/SelfTest/Baselines/console.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/console.sw.multi.approved.txt
index 9cba323d9b0a409c01f7ee93fbc323babda82f4f..4cc942dd49d739cf7f8e95ee1a0ab0bc6242e3ea 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/console.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/console.sw.multi.approved.txt
@@ -1,4 +1,4 @@
-Filters: ~[!nonportable]~[!benchmark]~[approvals] *
+Filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
Randomness seeded to: 1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -164,20 +164,20 @@ with expansion:
-------------------------------------------------------------------------------
#1905 -- test spec parser properly clears internal state between compound tests
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase("spec . char")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase("spec , char")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( spec.matches(*fakeTestCase(R"(spec \, char)")) )
with expansion:
!false
@@ -186,20 +186,20 @@ with expansion:
#1912 -- test spec parser handles escaping
Various parentheses
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec {a} char)")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec [a] char)")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( spec.matches(*fakeTestCase("differs but has similar tag", "[a]")) )
with expansion:
!false
@@ -208,10 +208,10 @@ with expansion:
#1912 -- test spec parser handles escaping
backslash in test name
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec \ char)")) )
with expansion:
true
@@ -759,6 +759,16 @@ with expansion:
0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.
00000000e+00])
+-------------------------------------------------------------------------------
+#2615 - Throwing in constructor generator fails test case but does not abort
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ failure to init
+
-------------------------------------------------------------------------------
#748 - captures with unexpected exceptions
outside assertions
@@ -3944,6 +3954,16 @@ with expansion:
==
"{** unexpected enum value **}"
+-------------------------------------------------------------------------------
+Empty generators can SKIP in constructor
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ This generator is empty
+
-------------------------------------------------------------------------------
Empty stream name opens cout stream
-------------------------------------------------------------------------------
@@ -3955,15 +3975,6 @@ Stream.tests.cpp:<line number>: PASSED:
with expansion:
true
--------------------------------------------------------------------------------
-Empty tag is not allowed
--------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
-...............................................................................
-
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE_THROWS( Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo ) )
-
-------------------------------------------------------------------------------
EndsWith string matcher
-------------------------------------------------------------------------------
@@ -4280,6 +4291,32 @@ Matchers.tests.cpp:<line number>: PASSED:
with expansion:
SpecialException::what special exception has value of 2
+-------------------------------------------------------------------------------
+Exception message can be matched
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) ) )
+with expansion:
+ DerivedException::what matches "starts with: "Derived""
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) ) )
+with expansion:
+ DerivedException::what matches "ends with: "::what""
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) ) )
+with expansion:
+ DerivedException::what matches "not starts with: "::what""
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_MATCHES( throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) ) )
+with expansion:
+ SpecialException::what matches "starts with: "Special""
+
-------------------------------------------------------------------------------
Exception messages can be tested for
exact match
@@ -4439,6 +4476,15 @@ Misc.tests.cpp:<line number>: PASSED:
with expansion:
3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+-------------------------------------------------------------------------------
+Filter generator throws exception for empty generator
+-------------------------------------------------------------------------------
+GeneratorsImpl.tests.cpp:<line number>
+...............................................................................
+
+GeneratorsImpl.tests.cpp:<line number>: PASSED:
+ REQUIRE_THROWS_AS( filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException )
+
-------------------------------------------------------------------------------
Floating point matchers: double
Relative
@@ -4624,6 +4670,18 @@ Matchers.tests.cpp:<line number>: PASSED:
Matchers.tests.cpp:<line number>: PASSED:
REQUIRE_THROWS_AS( WithinRel( 1., 1. ), std::domain_error )
+-------------------------------------------------------------------------------
+Floating point matchers: double
+ IsNaN
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( 1., !IsNaN() )
+with expansion:
+ 1.0 not is NaN
+
-------------------------------------------------------------------------------
Floating point matchers: float
Relative
@@ -4817,6 +4875,18 @@ Matchers.tests.cpp:<line number>: PASSED:
Matchers.tests.cpp:<line number>: PASSED:
REQUIRE_THROWS_AS( WithinRel( 1.f, 1.f ), std::domain_error )
+-------------------------------------------------------------------------------
+Floating point matchers: float
+ IsNaN
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( 1., !IsNaN() )
+with expansion:
+ 1.0 not is NaN
+
-------------------------------------------------------------------------------
Generators -- adapters
Filtering by predicate
@@ -8054,2170 +8124,1238 @@ Matchers.tests.cpp:<line number>: PASSED:
REQUIRE_NOTHROW( ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher() )
-------------------------------------------------------------------------------
-Parse test names and tags
- Empty test spec should have no filters
+Parse uints
+ proper inputs
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Parse.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "0" ) == Optional<unsigned int>{ 0 } )
with expansion:
- false == false
+ {?} == {?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "100" ) == Optional<unsigned int>{ 100 } )
with expansion:
- false == false
+ {?} == {?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 } )
with expansion:
- false == false
+ {?} == {?}
+
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE( parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 } )
+with expansion:
+ {?} == {?}
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from empty string should have no filters
+Parse uints
+ Bad inputs
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Parse.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "!!KJHF*#" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "-1" ) )
with expansion:
- false == false
+ !{?}
--------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from just a comma should have no filters
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "4294967296" ) )
+with expansion:
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "42949672964294967296429496729642949672964294967296" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "2 4" ) )
with expansion:
- false == false
+ !{?}
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Parse.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( parseUInt( "0x<hex digits>", 10 ) )
with expansion:
- false == false
+ !{?}
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from name should have one filter
+Parsed tags are matched case insensitive
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpecParser.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.hasFilters() )
with expansion:
- true == true
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.getInvalidSpecs().empty() )
with expansion:
- false == false
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.matches( testCase ) )
with expansion:
- true == true
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from quoted name should have one filter
+Parsing sharding-related cli flags
+ shard-count
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( cli.parse({ "test", "--shard-count=8" }) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ REQUIRE( config.shardCount == 8 )
with expansion:
- true == true
+ 8 == 8
-------------------------------------------------------------------------------
-Parse test names and tags
- Test spec from name should have one filter
+Parsing sharding-related cli flags
+ Negative shard count reports error
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK_FALSE( result )
with expansion:
- true == true
+ !{?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" ) )
with expansion:
- false == false
+ "Could not parse '-1' as shard count" contains: "Could not parse '-1' as
+ shard count"
+
+-------------------------------------------------------------------------------
+Parsing sharding-related cli flags
+ Zero shard count reports error
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK_FALSE( result )
with expansion:
- true == true
+ !{?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring( "Shard count must be positive" ) )
with expansion:
- false == false
+ "Shard count must be positive" contains: "Shard count must be positive"
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at the start
+Parsing sharding-related cli flags
+ shard-index
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( cli.parse({ "test", "--shard-index=2" }) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( config.shardIndex == 2 )
with expansion:
- false == false
+ 2 == 2
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Parsing sharding-related cli flags
+ Negative shard index reports error
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ CHECK_FALSE( result )
with expansion:
- false == false
+ !{?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( parseTestSpec( "*a" ).matches( *tcA ) == true )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" ) )
with expansion:
- true == true
+ "Could not parse '-12' as shard index" contains: "Could not parse '-12' as
+ shard index"
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at the end
+Parsing sharding-related cli flags
+ Shard index 0 is accepted
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({ "test", "--shard-index=0" }) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.shardIndex == 0 )
with expansion:
- false == false
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Parsing tags with non-alphabetical characters is pass-through
+-------------------------------------------------------------------------------
+TestSpecParser.tests.cpp:<line number>
+...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.hasFilters() )
with expansion:
- true == true
+ true
+with message:
+ tagString := "[tag with spaces]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.getInvalidSpecs().empty() )
with expansion:
- false == false
+ true
+with message:
+ tagString := "[tag with spaces]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( parseTestSpec( "a*" ).matches( *tcA ) == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.matches( testCase ) )
with expansion:
- true == true
+ true
+with message:
+ tagString := "[tag with spaces]"
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at both ends
+Parsing tags with non-alphabetical characters is pass-through
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpecParser.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.hasFilters() )
with expansion:
- true == true
+ true
+with message:
+ tagString := "[I said "good day" sir!]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.getInvalidSpecs().empty() )
with expansion:
- false == false
+ true
+with message:
+ tagString := "[I said "good day" sir!]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+TestSpecParser.tests.cpp:<line number>: PASSED:
+ REQUIRE( spec.matches( testCase ) )
with expansion:
- false == false
+ true
+with message:
+ tagString := "[I said "good day" sir!]"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Parsing warnings
+ NoAssertions
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( cli.parse( { "test", "-w", "NoAssertions" } ) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( parseTestSpec( "*a*" ).matches( *tcA ) == true )
+ REQUIRE( config.warnings == WarnAbout::NoAssertions )
with expansion:
- true == true
+ 1 == 1
-------------------------------------------------------------------------------
-Parse test names and tags
- Redundant wildcard at the start
+Parsing warnings
+ NoTests is no longer supported
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ REQUIRE_FALSE( cli.parse( { "test", "-w", "NoTests" } ) )
with expansion:
- true == true
+ !{?}
+
+-------------------------------------------------------------------------------
+Parsing warnings
+ Combining multiple warnings
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( cli.parse( { "test", "--warn", "NoAssertions", "--warn", "UnmatchedTestSpec" } ) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) )
with expansion:
- false == false
+ 3 == 3
-------------------------------------------------------------------------------
-Parse test names and tags
- Redundant wildcard at the end
+Pointers can be compared to null
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Condition.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( p == 0 )
with expansion:
- true == true
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( p == pNULL )
with expansion:
- true == true
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( p != 0 )
with expansion:
- false == false
+ 0x<hex digits> != 0
--------------------------------------------------------------------------------
-Parse test names and tags
- Redundant wildcard at both ends
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( cp != 0 )
+with expansion:
+ 0x<hex digits> != 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( cpc != 0 )
with expansion:
- true == true
+ 0x<hex digits> != 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( returnsNull() == 0 )
with expansion:
- true == true
+ {null string} == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( returnsConstNull() == 0 )
with expansion:
- false == false
+ {null string} == 0
+
+Condition.tests.cpp:<line number>: PASSED:
+ REQUIRE( 0 != p )
+with expansion:
+ 0 != 0x<hex digits>
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcard at both ends, redundant at start
+Precision of floating point stringification can be set
+ Floats
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+ToStringGeneral.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ CHECK( str1.size() == 3 + 5 )
with expansion:
- true == true
+ 8 == 8
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( str2.size() == 3 + 10 )
with expansion:
- false == false
+ 13 == 13
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Precision of floating point stringification can be set
+ Double
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ CHECK( str1.size() == 2 + 5 )
with expansion:
- true == true
+ 7 == 7
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( str2.size() == 2 + 15 )
with expansion:
- true == true
+ 17 == 17
-------------------------------------------------------------------------------
-Parse test names and tags
- Just wildcard
+Predicate matcher can accept const char*
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Matchers.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( "foo", Predicate<const char*>( []( const char* const& ) { return true; } ) )
with expansion:
- true == true
+ "foo" matches undescribed predicate
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ empty args don't cause a crash
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ CHECK( config.processName == "" )
with expansion:
- true == true
+ "" == ""
-------------------------------------------------------------------------------
-Parse test names and tags
- Single tag
+Process can be configured on command line
+ default - no arguments
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( result )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( config.processName == "test" )
with expansion:
- true == true
+ "test" == "test"
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( config.shouldDebugBreak == false )
with expansion:
false == false
--------------------------------------------------------------------------------
-Parse test names and tags
- Single tag, two matches
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( config.abortAfter == -1 )
with expansion:
- true == true
+ -1 == -1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( config.noThrow == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( config.reporterSpecifications.empty() )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK_FALSE( cfg.hasTestFilters() )
with expansion:
- true == true
-
--------------------------------------------------------------------------------
-Parse test names and tags
- Two tags
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+ !false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cfg.getReporterSpecs().size() == 1 )
with expansion:
- true == true
+ 1 == 1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ CHECK( cfg.getReporterSpecs()[0] == Catch::ReporterSpec{ expectedReporter, {}, {}, {} } )
with expansion:
- false == false
+ {?} == {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ CHECK( cfg.getProcessedReporterSpecs().size() == 1 )
with expansion:
- false == false
+ 1 == 1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( cfg.getProcessedReporterSpecs()[0] == Catch::ProcessedReporterSpec{ expectedReporter, std::string{}, Catch::ColourMode::PlatformDefault, {} } )
with expansion:
- true == true
+ {?} == {?}
-------------------------------------------------------------------------------
-Parse test names and tags
- Two tags, spare separated
+Process can be configured on command line
+ test lists
+ Specify one test case using
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( cfg.hasTestFilters() )
with expansion:
- false == false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) )
with expansion:
- true == true
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Wildcarded name and tag
+Process can be configured on command line
+ test lists
+ Specify one test case exclusion using exclude:
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( cfg.hasTestFilters() )
with expansion:
- false == false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
with expansion:
- false == false
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Single tag exclusion
+Process can be configured on command line
+ test lists
+ Specify one test case exclusion using ~
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( cfg.hasTestFilters() )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
with expansion:
false == false
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
with expansion:
- false == false
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- One tag exclusion and one tag inclusion
+Process can be configured on command line
+ reporter
+ -r/console
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", {}, {}, {} } } )
with expansion:
- false == false
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
+
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ -r/xml
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", {}, {}, {} } } )
with expansion:
- false == false
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-------------------------------------------------------------------------------
-Parse test names and tags
- One tag exclusion and one wldcarded name inclusion
+Process can be configured on command line
+ reporter
+ --reporter/junit
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "junit", {}, {}, {} } } )
with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
-with expansion:
- true == true
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-------------------------------------------------------------------------------
-Parse test names and tags
- One tag exclusion, using exclude:, and one wldcarded name inclusion
+Process can be configured on command line
+ reporter
+ must match one of the available ones
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( !result )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Unrecognized reporter") )
with expansion:
- false == false
+ "Unrecognized reporter, 'unsupported'. Check available with --list-reporters"
+ contains: "Unrecognized reporter"
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ With output file
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( result )
with expansion:
- false == false
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "out.txt"s, {}, {} } } )
with expansion:
- true == true
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-------------------------------------------------------------------------------
-Parse test names and tags
- name exclusion
+Process can be configured on command line
+ reporter
+ With Windows-like absolute path as output file
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( result )
with expansion:
- true == true
+ {?}
+with message:
+ result.errorMessage() := ""
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "C:\\Temp\\out.txt"s, {}, {} } } )
with expansion:
- true == true
+ { {?} } == { {?} }
+with message:
+ result.errorMessage() := ""
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ Multiple reporters
+ All with output files
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "junit::out=output-junit.xml" }) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "junit", "output-junit.xml"s, {}, {} } } )
with expansion:
- true == true
+ { {?}, {?} } == { {?}, {?} }
-------------------------------------------------------------------------------
-Parse test names and tags
- wildcarded name exclusion
+Process can be configured on command line
+ reporter
+ Multiple reporters
+ Mixed output files and default output
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "console" }) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "console", {}, {}, {} } } )
with expansion:
- true == true
+ { {?}, {?} } == { {?}, {?} }
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ reporter
+ Multiple reporters
+ cannot have multiple reporters with default output
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( !result )
with expansion:
- false == false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file.") )
with expansion:
- false == false
+ "Only one reporter may have unspecified output file." contains: "Only one
+ reporter may have unspecified output file."
-------------------------------------------------------------------------------
-Parse test names and tags
- wildcarded name exclusion with tag inclusion
+Process can be configured on command line
+ debugger
+ -b
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
-with expansion:
- true == true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
+ CHECK( cli.parse({"test", "-b"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ REQUIRE( config.shouldDebugBreak == true )
with expansion:
true == true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
-with expansion:
- false == false
-
-------------------------------------------------------------------------------
-Parse test names and tags
- wildcarded name exclusion, using exclude:, with tag inclusion
+Process can be configured on command line
+ debugger
+ --break
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({"test", "--break"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == true )
+ REQUIRE( config.shouldDebugBreak )
with expansion:
- true == true
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == true )
-with expansion:
- true == true
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ -a aborts after first failure
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( cli.parse({"test", "-a"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( config.abortAfter == 1 )
with expansion:
- false == false
+ 1 == 1
-------------------------------------------------------------------------------
-Parse test names and tags
- two wildcarded names
+Process can be configured on command line
+ abort
+ -x 2 aborts after two failures
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( cli.parse({"test", "-x", "2"}) )
with expansion:
- true == true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.abortAfter == 2 )
with expansion:
- false == false
+ 2 == 2
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ -x must be numeric
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == true )
+ CHECK( !result )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("convert") && ContainsSubstring("oops") )
with expansion:
- false == false
+ "Unable to convert 'oops' to destination type" ( contains: "convert" and
+ contains: "oops" )
-------------------------------------------------------------------------------
-Parse test names and tags
- empty tag
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 0 == 0
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 1 == 1
-------------------------------------------------------------------------------
-Parse test names and tags
- empty quoted name
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 2 == 2
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ Accepted options
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == false )
+ REQUIRE( config.waitForKeypress == std::get<1>(input) )
with expansion:
- false == false
+ 3 == 3
-------------------------------------------------------------------------------
-Parse test names and tags
- quoted string followed by tag exclusion
+Process can be configured on command line
+ abort
+ wait-for-keypress
+ invalid options are reported
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.hasFilters() == true )
+ CHECK( !result )
with expansion:
- true == true
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcA ) == false )
+ REQUIRE_THAT( result.errorMessage(), ContainsSubstring("never") && ContainsSubstring("both") )
with expansion:
- false == false
+ "keypress argument must be one of: never, start, exit or both. 'sometimes'
+ not recognised" ( contains: "never" and contains: "both" )
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcB ) == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Process can be configured on command line
+ nothrow
+ -e
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcC ) == false )
+ CHECK( cli.parse({"test", "-e"}) )
with expansion:
- false == false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *tcD ) == true )
+ REQUIRE( config.noThrow )
with expansion:
- true == true
+ true
-------------------------------------------------------------------------------
-Parse test names and tags
- Leading and trailing spaces in test spec
+Process can be configured on command line
+ nothrow
+ --nothrow
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) )
+ CHECK( cli.parse({"test", "--nothrow"}) )
with expansion:
- true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) )
+ REQUIRE( config.noThrow )
with expansion:
true
-------------------------------------------------------------------------------
-Parse test names and tags
- Leading and trailing spaces in test name
+Process can be configured on command line
+ output filename
+ -o filename
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) )
+ CHECK( cli.parse({"test", "-o", "filename.ext"}) )
with expansion:
- true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) )
+ REQUIRE( config.defaultOutputFilename == "filename.ext" )
with expansion:
- true
+ "filename.ext" == "filename.ext"
-------------------------------------------------------------------------------
-Parse test names and tags
- Shortened hide tags are split apart when parsing
+Process can be configured on command line
+ output filename
+ --out
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) )
+ CHECK( cli.parse({"test", "--out", "filename.ext"}) )
with expansion:
- true
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("only foo", "[foo]")) )
+ REQUIRE( config.defaultOutputFilename == "filename.ext" )
with expansion:
- !false
+ "filename.ext" == "filename.ext"
-------------------------------------------------------------------------------
-Parse test names and tags
- Shortened hide tags also properly handle exclusion
+Process can be configured on command line
+ combinations
+ Single character flags can be combined
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) )
+ CHECK( cli.parse({"test", "-abe"}) )
with expansion:
- !false
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("only foo", "[foo]")) )
+ CHECK( config.abortAfter == 1 )
with expansion:
- !false
+ 1 == 1
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( spec.matches(*fakeTestCase("only hidden", "[.]")) )
+ CHECK( config.shouldDebugBreak )
with expansion:
- !false
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")) )
+ CHECK( config.noThrow == true )
with expansion:
- true
+ true == true
-------------------------------------------------------------------------------
-Parsed tags are matched case insensitive
+Process can be configured on command line
+ use-colour
+ without option
-------------------------------------------------------------------------------
-TestSpecParser.tests.cpp:<line number>
+CmdLine.tests.cpp:<line number>
...............................................................................
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.hasFilters() )
-with expansion:
- true
-
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.getInvalidSpecs().empty() )
+CmdLine.tests.cpp:<line number>: PASSED:
+ CHECK( cli.parse({"test"}) )
with expansion:
- true
+ {?}
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.matches( testCase ) )
+CmdLine.tests.cpp:<line number>: PASSED:
+ REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
with expansion:
- true
+ 0 == 0
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- shard-count
+Process can be configured on command line
+ use-colour
+ auto
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--shard-count=8" }) )
+ CHECK( cli.parse( { "test", "--colour-mode", "default" } ) )
with expansion:
{?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shardCount == 8 )
+ REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
with expansion:
- 8 == 8
+ 0 == 0
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Negative shard count reports error
+Process can be configured on command line
+ use-colour
+ yes
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( result )
+ CHECK( cli.parse({"test", "--colour-mode", "ansi"}) )
with expansion:
- !{?}
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Shard count must be a positive number") )
+ REQUIRE( config.defaultColourMode == ColourMode::ANSI )
with expansion:
- "Shard count must be a positive number" contains: "Shard count must be a
- positive number"
+ 1 == 1
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Zero shard count reports error
+Process can be configured on command line
+ use-colour
+ no
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( result )
+ CHECK( cli.parse({"test", "--colour-mode", "none"}) )
with expansion:
- !{?}
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Shard count must be a positive number") )
+ REQUIRE( config.defaultColourMode == ColourMode::None )
with expansion:
- "Shard count must be a positive number" contains: "Shard count must be a
- positive number"
+ 3 == 3
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- shard-index
+Process can be configured on command line
+ use-colour
+ error
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--shard-index=2" }) )
+ CHECK( !result )
with expansion:
- {?}
+ true
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shardIndex == 2 )
+ CHECK_THAT( result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) )
with expansion:
- 2 == 2
+ "colour mode must be one of: default, ansi, win32, or none. 'wrong' is not
+ recognised" contains: "colour mode must be one of"
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Negative shard index reports error
+Process can be configured on command line
+ Benchmark options
+ samples
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( result )
+ CHECK( cli.parse({ "test", "--benchmark-samples=200" }) )
with expansion:
- !{?}
+ {?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number") )
+ REQUIRE( config.benchmarkSamples == 200 )
with expansion:
- "Shard index must be a non-negative number" contains: "Shard index must be a
- non-negative number"
+ 200 == 200
-------------------------------------------------------------------------------
-Parsing sharding-related cli flags
- Shard index 0 is accepted
+Process can be configured on command line
+ Benchmark options
+ resamples
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--shard-index=0" }) )
+ CHECK( cli.parse({ "test", "--benchmark-resamples=20000" }) )
with expansion:
{?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shardIndex == 0 )
+ REQUIRE( config.benchmarkResamples == 20000 )
with expansion:
- 0 == 0
+ 20000 (0x<hex digits>) == 20000 (0x<hex digits>)
-------------------------------------------------------------------------------
-Parsing tags with non-alphabetical characters is pass-through
+Process can be configured on command line
+ Benchmark options
+ confidence-interval
-------------------------------------------------------------------------------
-TestSpecParser.tests.cpp:<line number>
+CmdLine.tests.cpp:<line number>
...............................................................................
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.hasFilters() )
-with expansion:
- true
-with message:
- tagString := "[tag with spaces]"
-
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.getInvalidSpecs().empty() )
+CmdLine.tests.cpp:<line number>: PASSED:
+ CHECK( cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) )
with expansion:
- true
-with message:
- tagString := "[tag with spaces]"
+ {?}
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.matches( testCase ) )
+CmdLine.tests.cpp:<line number>: PASSED:
+ REQUIRE( config.benchmarkConfidenceInterval == Catch::Approx(0.99) )
with expansion:
- true
-with message:
- tagString := "[tag with spaces]"
+ 0.99 == Approx( 0.99 )
-------------------------------------------------------------------------------
-Parsing tags with non-alphabetical characters is pass-through
+Process can be configured on command line
+ Benchmark options
+ no-analysis
-------------------------------------------------------------------------------
-TestSpecParser.tests.cpp:<line number>
+CmdLine.tests.cpp:<line number>
...............................................................................
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.hasFilters() )
-with expansion:
- true
-with message:
- tagString := "[I said "good day" sir!]"
-
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.getInvalidSpecs().empty() )
+CmdLine.tests.cpp:<line number>: PASSED:
+ CHECK( cli.parse({ "test", "--benchmark-no-analysis" }) )
with expansion:
- true
-with message:
- tagString := "[I said "good day" sir!]"
+ {?}
-TestSpecParser.tests.cpp:<line number>: PASSED:
- REQUIRE( spec.matches( testCase ) )
+CmdLine.tests.cpp:<line number>: PASSED:
+ REQUIRE( config.benchmarkNoAnalysis )
with expansion:
true
-with message:
- tagString := "[I said "good day" sir!]"
-------------------------------------------------------------------------------
-Parsing warnings
- NoAssertions
+Process can be configured on command line
+ Benchmark options
+ warmup-time
-------------------------------------------------------------------------------
CmdLine.tests.cpp:<line number>
...............................................................................
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cli.parse( { "test", "-w", "NoAssertions" } ) )
+ CHECK( cli.parse({ "test", "--benchmark-warmup-time=10" }) )
with expansion:
{?}
CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.warnings == WarnAbout::NoAssertions )
+ REQUIRE( config.benchmarkWarmupTime == 10 )
with expansion:
- 1 == 1
+ 10 == 10
-------------------------------------------------------------------------------
-Parsing warnings
- NoTests is no longer supported
+Product with differing arities - std::tuple<int, double, float>
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( cli.parse( { "test", "-w", "NoTests" } ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::tuple_size<TestType>::value >= 1 )
with expansion:
- !{?}
+ 3 >= 1
-------------------------------------------------------------------------------
-Parsing warnings
- Combining multiple warnings
+Product with differing arities - std::tuple<int, double>
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cli.parse( { "test", "--warn", "NoAssertions", "--warn", "UnmatchedTestSpec" } ) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::tuple_size<TestType>::value >= 1 )
with expansion:
- 3 == 3
+ 2 >= 1
-------------------------------------------------------------------------------
-Pointers can be compared to null
+Product with differing arities - std::tuple<int>
-------------------------------------------------------------------------------
-Condition.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( p == 0 )
-with expansion:
- 0 == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( p == pNULL )
-with expansion:
- 0 == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( p != 0 )
-with expansion:
- 0x<hex digits> != 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( cp != 0 )
-with expansion:
- 0x<hex digits> != 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( cpc != 0 )
-with expansion:
- 0x<hex digits> != 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( returnsNull() == 0 )
-with expansion:
- {null string} == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( returnsConstNull() == 0 )
-with expansion:
- {null string} == 0
-
-Condition.tests.cpp:<line number>: PASSED:
- REQUIRE( 0 != p )
-with expansion:
- 0 != 0x<hex digits>
-
--------------------------------------------------------------------------------
-Precision of floating point stringification can be set
- Floats
--------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
-...............................................................................
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- CHECK( str1.size() == 3 + 5 )
-with expansion:
- 8 == 8
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( str2.size() == 3 + 10 )
-with expansion:
- 13 == 13
-
--------------------------------------------------------------------------------
-Precision of floating point stringification can be set
- Double
--------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
-...............................................................................
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- CHECK( str1.size() == 2 + 5 )
-with expansion:
- 7 == 7
-
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( str2.size() == 2 + 15 )
-with expansion:
- 17 == 17
-
--------------------------------------------------------------------------------
-Predicate matcher can accept const char*
--------------------------------------------------------------------------------
-Matchers.tests.cpp:<line number>
-...............................................................................
-
-Matchers.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( "foo", Predicate<const char*>( []( const char* const& ) { return true; } ) )
-with expansion:
- "foo" matches undescribed predicate
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- empty args don't cause a crash
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.processName == "" )
-with expansion:
- "" == ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- default - no arguments
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.processName == "test" )
-with expansion:
- "test" == "test"
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.shouldDebugBreak == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.abortAfter == -1 )
-with expansion:
- -1 == -1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.noThrow == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.reporterSpecifications.empty() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_FALSE( cfg.hasTestFilters() )
-with expansion:
- !false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getReporterSpecs().size() == 1 )
-with expansion:
- 1 == 1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getReporterSpecs()[0] == Catch::ReporterSpec{ expectedReporter, {}, {}, {} } )
-with expansion:
- {?} == {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getProcessedReporterSpecs().size() == 1 )
-with expansion:
- 1 == 1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cfg.getProcessedReporterSpecs()[0] == Catch::ProcessedReporterSpec{ expectedReporter, std::string{}, Catch::ColourMode::PlatformDefault, {} } )
-with expansion:
- {?} == {?}
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- test lists
- Specify one test case using
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.hasTestFilters() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- test lists
- Specify one test case exclusion using exclude:
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.hasTestFilters() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- test lists
- Specify one test case exclusion using ~
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.hasTestFilters() )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("test1")) == false )
-with expansion:
- false == false
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")) )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- -r/console
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", {}, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- -r/xml
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", {}, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- --reporter/junit
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "junit", {}, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- must match one of the available ones
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Unrecognized reporter") )
-with expansion:
- "Unrecognized reporter, 'unsupported'. Check available with --list-reporters"
- contains: "Unrecognized reporter"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- With output file
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "out.txt"s, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- With Windows-like absolute path as output file
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( result )
-with expansion:
- {?}
-with message:
- result.errorMessage() := ""
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "console", "C:\\Temp\\out.txt"s, {}, {} } } )
-with expansion:
- { {?} } == { {?} }
-with message:
- result.errorMessage() := ""
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- Multiple reporters
- All with output files
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "junit::out=output-junit.xml" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "junit", "output-junit.xml"s, {}, {} } } )
-with expansion:
- { {?}, {?} } == { {?}, {?} }
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- Multiple reporters
- Mixed output files and default output
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "console" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.reporterSpecifications == vec_Specs{ { "xml", "output.xml"s, {}, {} }, { "console", {}, {}, {} } } )
-with expansion:
- { {?}, {?} } == { {?}, {?} }
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- reporter
- Multiple reporters
- cannot have multiple reporters with default output
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file.") )
-with expansion:
- "Only one reporter may have unspecified output file." contains: "Only one
- reporter may have unspecified output file."
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- debugger
- -b
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-b"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shouldDebugBreak == true )
-with expansion:
- true == true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- debugger
- --break
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--break"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.shouldDebugBreak )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- -a aborts after first failure
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-a"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.abortAfter == 1 )
-with expansion:
- 1 == 1
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- -x 2 aborts after two failures
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-x", "2"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.abortAfter == 2 )
-with expansion:
- 2 == 2
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- -x must be numeric
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("convert") && ContainsSubstring("oops") )
-with expansion:
- "Unable to convert 'oops' to destination type" ( contains: "convert" and
- contains: "oops" )
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 1 == 1
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 2 == 2
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- Accepted options
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.waitForKeypress == std::get<1>(input) )
-with expansion:
- 3 == 3
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- abort
- wait-for-keypress
- invalid options are reported
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( result.errorMessage(), ContainsSubstring("never") && ContainsSubstring("both") )
-with expansion:
- "keypress argument must be one of: never, start, exit or both. 'sometimes'
- not recognised" ( contains: "never" and contains: "both" )
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- nothrow
- -e
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-e"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.noThrow )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- nothrow
- --nothrow
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--nothrow"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.noThrow )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- output filename
- -o filename
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-o", "filename.ext"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultOutputFilename == "filename.ext" )
-with expansion:
- "filename.ext" == "filename.ext"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- output filename
- --out
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--out", "filename.ext"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultOutputFilename == "filename.ext" )
-with expansion:
- "filename.ext" == "filename.ext"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- combinations
- Single character flags can be combined
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "-abe"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.abortAfter == 1 )
-with expansion:
- 1 == 1
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.shouldDebugBreak )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( config.noThrow == true )
-with expansion:
- true == true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- without option
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
-with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- auto
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse( { "test", "--colour-mode", "default" } ) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault )
-with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- yes
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--colour-mode", "ansi"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::ANSI )
-with expansion:
- 1 == 1
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- no
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({"test", "--colour-mode", "none"}) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.defaultColourMode == ColourMode::None )
-with expansion:
- 3 == 3
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- use-colour
- error
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( !result )
-with expansion:
- true
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK_THAT( result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) )
-with expansion:
- "colour mode must be one of: default, ansi, win32, or none. 'wrong' is not
- recognised" contains: "colour mode must be one of"
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- samples
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-samples=200" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkSamples == 200 )
-with expansion:
- 200 == 200
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- resamples
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-resamples=20000" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkResamples == 20000 )
-with expansion:
- 20000 (0x<hex digits>) == 20000 (0x<hex digits>)
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- confidence-interval
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-confidence-interval=0.99" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkConfidenceInterval == Catch::Approx(0.99) )
-with expansion:
- 0.99 == Approx( 0.99 )
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- no-analysis
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-no-analysis" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkNoAnalysis )
-with expansion:
- true
-
--------------------------------------------------------------------------------
-Process can be configured on command line
- Benchmark options
- warmup-time
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
-
-CmdLine.tests.cpp:<line number>: PASSED:
- CHECK( cli.parse({ "test", "--benchmark-warmup-time=10" }) )
-with expansion:
- {?}
-
-CmdLine.tests.cpp:<line number>: PASSED:
- REQUIRE( config.benchmarkWarmupTime == 10 )
-with expansion:
- 10 == 10
-
--------------------------------------------------------------------------------
-Product with differing arities - std::tuple<int, double, float>
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
-
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( std::tuple_size<TestType>::value >= 1 )
-with expansion:
- 3 >= 1
-
--------------------------------------------------------------------------------
-Product with differing arities - std::tuple<int, double>
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
-
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( std::tuple_size<TestType>::value >= 1 )
-with expansion:
- 2 >= 1
-
--------------------------------------------------------------------------------
-Product with differing arities - std::tuple<int>
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
-
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( std::tuple_size<TestType>::value >= 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::tuple_size<TestType>::value >= 1 )
with expansion:
1 >= 1
@@ -11247,889 +10385,1179 @@ Approx.tests.cpp:<line number>: PASSED:
with expansion:
1.23 == Approx( 1.23 )
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d != Approx( 1.22 ) )
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d != Approx( 1.22 ) )
+with expansion:
+ 1.23 != Approx( 1.22 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d != Approx( 1.24 ) )
+with expansion:
+ 1.23 != Approx( 1.24 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d == 1.23_a )
+with expansion:
+ 1.23 == Approx( 1.23 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( d != 1.22_a )
+with expansion:
+ 1.23 != Approx( 1.22 )
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( Approx( d ) == 1.23 )
+with expansion:
+ Approx( 1.23 ) == 1.23
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( Approx( d ) != 1.22 )
+with expansion:
+ Approx( 1.23 ) != 1.22
+
+Approx.tests.cpp:<line number>: PASSED:
+ REQUIRE( Approx( d ) != 1.24 )
+with expansion:
+ Approx( 1.23 ) != 1.24
+
+-------------------------------------------------------------------------------
+Standard output from all sections is reported
+ one
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'one'
+
+-------------------------------------------------------------------------------
+Standard output from all sections is reported
+ two
+-------------------------------------------------------------------------------
+Message.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'two'
+
+-------------------------------------------------------------------------------
+StartsWith string matcher
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: FAILED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "This String"
+
+Matchers.tests.cpp:<line number>: FAILED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "string" (case
+ insensitive)
+
+-------------------------------------------------------------------------------
+Static arrays are convertible to string
+ Single item
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( Catch::Detail::stringify(singular) == "{ 1 }" )
+with expansion:
+ "{ 1 }" == "{ 1 }"
+
+-------------------------------------------------------------------------------
+Static arrays are convertible to string
+ Multiple
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( Catch::Detail::stringify(arr) == "{ 3, 2, 1 }" )
+with expansion:
+ "{ 3, 2, 1 }" == "{ 3, 2, 1 }"
+
+-------------------------------------------------------------------------------
+Static arrays are convertible to string
+ Non-trivial inner items
+-------------------------------------------------------------------------------
+ToStringGeneral.tests.cpp:<line number>
+...............................................................................
+
+ToStringGeneral.tests.cpp:<line number>: PASSED:
+ REQUIRE( Catch::Detail::stringify(arr) == R"({ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } })" )
+with expansion:
+ "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+ ==
+ "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+
+-------------------------------------------------------------------------------
+String matchers
+-------------------------------------------------------------------------------
+Matchers.tests.cpp:<line number>
+...............................................................................
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string" ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "string"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "string" (case
+ insensitive)
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), ContainsSubstring( "abc" ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "abc"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), ContainsSubstring( "aBC", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" contains: "abc" (case
+ insensitive)
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "this" ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "this"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), StartsWith( "THIS", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" starts with: "this" (case
+ insensitive)
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) )
+with expansion:
+ "this string contains 'abc' as a substring" ends with: "substring"
+
+Matchers.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( testStringForMatching(), EndsWith( " SuBsTrInG", Catch::CaseSensitive::No ) )
+with expansion:
+ "this string contains 'abc' as a substring" ends with: " substring" (case
+ insensitive)
+
+-------------------------------------------------------------------------------
+StringRef
+ Empty string
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( empty.empty() )
+with expansion:
+ true
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( empty.size() == 0 )
+with expansion:
+ 0 == 0
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp( empty.data(), "" ) == 0 )
+with expansion:
+ 0 == 0
+
+-------------------------------------------------------------------------------
+StringRef
+ From string literal
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.empty() == false )
+with expansion:
+ false == false
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.size() == 5 )
+with expansion:
+ 5 == 5
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp( rawChars, "hello" ) == 0 )
+with expansion:
+ 0 == 0
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.data() == rawChars )
+with expansion:
+ "hello" == "hello"
+
+-------------------------------------------------------------------------------
+StringRef
+ From sub-string
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( original == "original" )
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE_NOTHROW( original.data() )
+
+-------------------------------------------------------------------------------
+StringRef
+ Copy construction is shallow
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( original.begin() == copy.begin() )
with expansion:
- 1.23 != Approx( 1.22 )
+ "original string" == "original string"
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d != Approx( 1.24 ) )
-with expansion:
- 1.23 != Approx( 1.24 )
+-------------------------------------------------------------------------------
+StringRef
+ Copy assignment is shallow
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d == 1.23_a )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( original.begin() == copy.begin() )
with expansion:
- 1.23 == Approx( 1.23 )
+ "original string" == "original string"
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( d != 1.22_a )
+-------------------------------------------------------------------------------
+StringRef
+ Substrings
+ zero-based substring
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss.empty() == false )
with expansion:
- 1.23 != Approx( 1.22 )
+ false == false
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( Approx( d ) == 1.23 )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss.size() == 5 )
with expansion:
- Approx( 1.23 ) == 1.23
+ 5 == 5
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( Approx( d ) != 1.22 )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strncmp( ss.data(), "hello", 5 ) == 0 )
with expansion:
- Approx( 1.23 ) != 1.22
+ 0 == 0
-Approx.tests.cpp:<line number>: PASSED:
- REQUIRE( Approx( d ) != 1.24 )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss == "hello" )
with expansion:
- Approx( 1.23 ) != 1.24
+ hello == "hello"
-------------------------------------------------------------------------------
-Standard output from all sections is reported
- one
+StringRef
+ Substrings
+ non-zero-based substring
-------------------------------------------------------------------------------
-Message.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( ss.size() == 6 )
+with expansion:
+ 6 == 6
-No assertions in section 'one'
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp( ss.data(), "world!" ) == 0 )
+with expansion:
+ 0 == 0
-------------------------------------------------------------------------------
-Standard output from all sections is reported
- two
+StringRef
+ Substrings
+ Pointer values of full refs should match
-------------------------------------------------------------------------------
-Message.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-
-No assertions in section 'two'
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.data() == s2.data() )
+with expansion:
+ "hello world!" == "hello world!"
-------------------------------------------------------------------------------
-StartsWith string matcher
+StringRef
+ Substrings
+ Pointer values of substring refs should also match
-------------------------------------------------------------------------------
-Matchers.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-Matchers.tests.cpp:<line number>: FAILED:
- CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
-with expansion:
- "this string contains 'abc' as a substring" starts with: "This String"
-
-Matchers.tests.cpp:<line number>: FAILED:
- CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.data() == ss.data() )
with expansion:
- "this string contains 'abc' as a substring" starts with: "string" (case
- insensitive)
+ "hello world!" == "hello world!"
-------------------------------------------------------------------------------
-Static arrays are convertible to string
- Single item
+StringRef
+ Substrings
+ Past the end substring
-------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( Catch::Detail::stringify(singular) == "{ 1 }" )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.substr(s.size() + 1, 123).empty() )
with expansion:
- "{ 1 }" == "{ 1 }"
+ true
-------------------------------------------------------------------------------
-Static arrays are convertible to string
- Multiple
+StringRef
+ Substrings
+ Substring off the end are trimmed
-------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( Catch::Detail::stringify(arr) == "{ 3, 2, 1 }" )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( std::strcmp(ss.data(), "world!") == 0 )
with expansion:
- "{ 3, 2, 1 }" == "{ 3, 2, 1 }"
+ 0 == 0
-------------------------------------------------------------------------------
-Static arrays are convertible to string
- Non-trivial inner items
+StringRef
+ Substrings
+ substring start after the end is empty
-------------------------------------------------------------------------------
-ToStringGeneral.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-ToStringGeneral.tests.cpp:<line number>: PASSED:
- REQUIRE( Catch::Detail::stringify(arr) == R"({ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } })" )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( s.substr(1'000'000, 1).empty() )
with expansion:
- "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
- ==
- "{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
+ true
-------------------------------------------------------------------------------
-String matchers
+StringRef
+ Comparisons are deep
-------------------------------------------------------------------------------
-Matchers.tests.cpp:<line number>
+String.tests.cpp:<line number>
...............................................................................
-Matchers.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string" ) )
+String.tests.cpp:<line number>: PASSED:
+ CHECK( reinterpret_cast<char*>(buffer1) != reinterpret_cast<char*>(buffer2) )
with expansion:
- "this string contains 'abc' as a substring" contains: "string"
+ "Hello" != "Hello"
-Matchers.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( testStringForMatching(), ContainsSubstring( "string", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( left == right )
with expansion:
- "this string contains 'abc' as a substring" contains: "string" (case
- insensitive)
+ Hello == Hello
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), ContainsSubstring( "abc" ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( left != left.substr(0, 3) )
with expansion:
- "this string contains 'abc' as a substring" contains: "abc"
+ Hello != Hel
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), ContainsSubstring( "aBC", Catch::CaseSensitive::No ) )
-with expansion:
- "this string contains 'abc' as a substring" contains: "abc" (case
- insensitive)
+-------------------------------------------------------------------------------
+StringRef
+ from std::string
+ implicitly constructed
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), StartsWith( "this" ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr == "a standard string" )
with expansion:
- "this string contains 'abc' as a substring" starts with: "this"
+ a standard string == "a standard string"
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), StartsWith( "THIS", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr.size() == stdStr.size() )
with expansion:
- "this string contains 'abc' as a substring" starts with: "this" (case
- insensitive)
+ 17 == 17
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) )
+-------------------------------------------------------------------------------
+StringRef
+ from std::string
+ explicitly constructed
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
+
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr == "a standard string" )
with expansion:
- "this string contains 'abc' as a substring" ends with: "substring"
+ a standard string == "a standard string"
-Matchers.tests.cpp:<line number>: PASSED:
- CHECK_THAT( testStringForMatching(), EndsWith( " SuBsTrInG", Catch::CaseSensitive::No ) )
+String.tests.cpp:<line number>: PASSED:
+ REQUIRE( sr.size() == stdStr.size() )
with expansion:
- "this string contains 'abc' as a substring" ends with: " substring" (case
- insensitive)
+ 17 == 17
-------------------------------------------------------------------------------
StringRef
- Empty string
+ from std::string
+ assigned
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( empty.empty() )
-with expansion:
- true
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( empty.size() == 0 )
+ REQUIRE( sr == "a standard string" )
with expansion:
- 0 == 0
+ a standard string == "a standard string"
String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp( empty.data(), "" ) == 0 )
+ REQUIRE( sr.size() == stdStr.size() )
with expansion:
- 0 == 0
+ 17 == 17
-------------------------------------------------------------------------------
StringRef
- From string literal
+ to std::string
+ explicitly constructed
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.empty() == false )
+ REQUIRE( stdStr == "a stringref" )
with expansion:
- false == false
+ "a stringref" == "a stringref"
String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.size() == 5 )
+ REQUIRE( stdStr.size() == sr.size() )
with expansion:
- 5 == 5
+ 11 == 11
+
+-------------------------------------------------------------------------------
+StringRef
+ to std::string
+ assigned
+-------------------------------------------------------------------------------
+String.tests.cpp:<line number>
+...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp( rawChars, "hello" ) == 0 )
+ REQUIRE( stdStr == "a stringref" )
with expansion:
- 0 == 0
+ "a stringref" == "a stringref"
String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.data() == rawChars )
+ REQUIRE( stdStr.size() == sr.size() )
with expansion:
- "hello" == "hello"
+ 11 == 11
-------------------------------------------------------------------------------
StringRef
- From sub-string
+ std::string += StringRef
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( original == "original" )
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE_NOTHROW( original.data() )
+ REQUIRE( lhs == "some string += the stringref contents" )
+with expansion:
+ "some string += the stringref contents"
+ ==
+ "some string += the stringref contents"
-------------------------------------------------------------------------------
StringRef
- Copy construction is shallow
+ StringRef + StringRef
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( original.begin() == copy.begin() )
+ REQUIRE( together == "abrakadabra" )
with expansion:
- "original string" == "original string"
+ "abrakadabra" == "abrakadabra"
-------------------------------------------------------------------------------
-StringRef
- Copy assignment is shallow
+StringRef at compilation time
+ Simple constructors
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( original.begin() == copy.begin() )
-with expansion:
- "original string" == "original string"
+with message:
+ empty.size() == 0
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ empty.begin() == empty.end()
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.size() == 3
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.data() == abc
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.begin() == abc
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.begin() != stringref.end()
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.substr(10, 0).empty()
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref.substr(2, 1).data() == abc + 2
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ stringref[1] == 'b'
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ shortened.size() == 2
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ shortened.data() == abc
+
+String.tests.cpp:<line number>: PASSED:
+with message:
+ shortened.begin() != shortened.end()
-------------------------------------------------------------------------------
-StringRef
- Substrings
- zero-based substring
+StringRef at compilation time
+ UDL construction
-------------------------------------------------------------------------------
String.tests.cpp:<line number>
...............................................................................
String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss.empty() == false )
-with expansion:
- false == false
+with message:
+ !(sr1.empty())
String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss.size() == 5 )
-with expansion:
- 5 == 5
+with message:
+ sr1.size() == 3
String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strncmp( ss.data(), "hello", 5 ) == 0 )
-with expansion:
- 0 == 0
+with message:
+ sr2.empty()
String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss == "hello" )
+with message:
+ sr2.size() == 0
+
+-------------------------------------------------------------------------------
+Stringifying char arrays with statically known sizes - char
+-------------------------------------------------------------------------------
+ToString.tests.cpp:<line number>
+...............................................................................
+
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
with expansion:
- hello == "hello"
+ ""abc"" == ""abc""
+
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+with expansion:
+ ""abc"" == ""abc""
-------------------------------------------------------------------------------
-StringRef
- Substrings
- non-zero-based substring
+Stringifying char arrays with statically known sizes - signed char
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToString.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( ss.size() == 6 )
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
with expansion:
- 6 == 6
+ ""abc"" == ""abc""
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp( ss.data(), "world!" ) == 0 )
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
with expansion:
- 0 == 0
+ ""abc"" == ""abc""
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Pointer values of full refs should match
+Stringifying char arrays with statically known sizes - unsigned char
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToString.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.data() == s2.data() )
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
with expansion:
- "hello world!" == "hello world!"
+ ""abc"" == ""abc""
+
+ToString.tests.cpp:<line number>: PASSED:
+ CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+with expansion:
+ ""abc"" == ""abc""
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Pointer values of substring refs should also match
+Stringifying std::chrono::duration helpers
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToStringChrono.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.data() == ss.data() )
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( minute == seconds )
with expansion:
- "hello world!" == "hello world!"
+ 1 m == 60 s
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( hour != seconds )
+with expansion:
+ 1 h != 60 s
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( micro != milli )
+with expansion:
+ 1 us != 1 ms
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( nano != micro )
+with expansion:
+ 1 ns != 1 us
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Past the end substring
+Stringifying std::chrono::duration with weird ratios
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToStringChrono.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.substr(s.size() + 1, 123).empty() )
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( half_minute != femto_second )
with expansion:
- true
+ 1 [30/1]s != 1 fs
+
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( pico_second != atto_second )
+with expansion:
+ 1 ps != 1 as
-------------------------------------------------------------------------------
-StringRef
- Substrings
- Substring off the end are trimmed
+Stringifying std::chrono::time_point<system_clock>
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+ToStringChrono.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( std::strcmp(ss.data(), "world!") == 0 )
+ToStringChrono.tests.cpp:<line number>: PASSED:
+ REQUIRE( now != later )
with expansion:
- 0 == 0
+ {iso8601-timestamp}
+ !=
+ {iso8601-timestamp}
-------------------------------------------------------------------------------
-StringRef
- Substrings
- substring start after the end is empty
+Tabs and newlines show in output
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( s.substr(1'000'000, 1).empty() )
+Misc.tests.cpp:<line number>: FAILED:
+ CHECK( s1 == s2 )
with expansion:
- true
+ "if ($b == 10) {
+ $a = 20;
+ }"
+ ==
+ "if ($b == 10) {
+ $a = 20;
+ }
+ "
-------------------------------------------------------------------------------
-StringRef
- Comparisons are deep
+Tag alias can be registered against tag patterns
+ The same tag alias can only be registered once
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- CHECK( reinterpret_cast<char*>(buffer1) != reinterpret_cast<char*>(buffer2) )
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "[@zzz]" ) )
with expansion:
- "Hello" != "Hello"
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "[@zzz]"
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( left == right )
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "file" ) )
with expansion:
- Hello == Hello
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "file"
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( left != left.substr(0, 3) )
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "2" ) )
with expansion:
- Hello != Hel
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "2"
+
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( what, ContainsSubstring( "10" ) )
+with expansion:
+ "error: tag alias, '[@zzz]' already registered.
+ First seen at: file:2
+ Redefined at: file:10" contains: "10"
-------------------------------------------------------------------------------
-StringRef
- from std::string
- implicitly constructed
+Tag alias can be registered against tag patterns
+ Tag aliases must be of the form [@name]
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr == "a standard string" )
-with expansion:
- a standard string == "a standard string"
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "[no ampersat]", "", Catch::SourceLineInfo( "file", 3 ) ) )
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr.size() == stdStr.size() )
-with expansion:
- 17 == 17
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "[the @ is not at the start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
+
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "@no square bracket at start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
+
+Tag.tests.cpp:<line number>: PASSED:
+ CHECK_THROWS( registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) ) )
-------------------------------------------------------------------------------
-StringRef
- from std::string
- explicitly constructed
+Tags with spaces and non-alphanumerical characters are accepted
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr == "a standard string" )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.tags.size() == 2 )
with expansion:
- a standard string == "a standard string"
+ 2 == 2
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr.size() == stdStr.size() )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( testCase.tags, VectorContains( Tag( "tag with spaces" ) ) && VectorContains( Tag( "I said \"good day\" sir!"_catch_sr ) ) )
with expansion:
- 17 == 17
+ { {?}, {?} } ( Contains: {?} and Contains: {?} )
-------------------------------------------------------------------------------
-StringRef
- from std::string
- assigned
+Template test case method with test types specified inside std::tuple - MyTypes
+- 0
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Class.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr == "a standard string" )
-with expansion:
- a standard string == "a standard string"
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( sr.size() == stdStr.size() )
+Class.tests.cpp:<line number>: PASSED:
+ REQUIRE( Template_Fixture<TestType>::m_a == 1 )
with expansion:
- 17 == 17
+ 1 == 1
-------------------------------------------------------------------------------
-StringRef
- to std::string
- explicitly constructed
+Template test case method with test types specified inside std::tuple - MyTypes
+- 1
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Class.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr == "a stringref" )
-with expansion:
- "a stringref" == "a stringref"
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr.size() == sr.size() )
+Class.tests.cpp:<line number>: PASSED:
+ REQUIRE( Template_Fixture<TestType>::m_a == 1 )
with expansion:
- 11 == 11
+ 1 == 1
-------------------------------------------------------------------------------
-StringRef
- to std::string
- assigned
+Template test case method with test types specified inside std::tuple - MyTypes
+- 2
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Class.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr == "a stringref" )
-with expansion:
- "a stringref" == "a stringref"
-
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( stdStr.size() == sr.size() )
+Class.tests.cpp:<line number>: PASSED:
+ REQUIRE( Template_Fixture<TestType>::m_a == 1 )
with expansion:
- 11 == 11
+ 1.0 == 1
-------------------------------------------------------------------------------
-StringRef
- std::string += StringRef
+Template test case with test types specified inside non-copyable and non-
+movable std::tuple - NonCopyableAndNonMovableTypes - 0
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( lhs == "some string += the stringref contents" )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- "some string += the stringref contents"
- ==
- "some string += the stringref contents"
+ 1 > 0
-------------------------------------------------------------------------------
-StringRef
- StringRef + StringRef
+Template test case with test types specified inside non-copyable and non-
+movable std::tuple - NonCopyableAndNonMovableTypes - 1
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
- REQUIRE( together == "abrakadabra" )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- "abrakadabra" == "abrakadabra"
+ 4 > 0
-------------------------------------------------------------------------------
-StringRef at compilation time
- Simple constructors
+Template test case with test types specified inside non-default-constructible
+std::tuple - MyNonDefaultConstructibleTypes - 0
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
-with message:
- empty.size() == 0
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- empty.begin() == empty.end()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.size() == 3
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.data() == abc
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.begin() == abc
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.begin() != stringref.end()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.substr(10, 0).empty()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref.substr(2, 1).data() == abc + 2
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- stringref[1] == 'b'
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- shortened.size() == 2
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- shortened.data() == abc
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- shortened.begin() != shortened.end()
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
+with expansion:
+ 1 > 0
-------------------------------------------------------------------------------
-StringRef at compilation time
- UDL construction
+Template test case with test types specified inside non-default-constructible
+std::tuple - MyNonDefaultConstructibleTypes - 1
-------------------------------------------------------------------------------
-String.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-String.tests.cpp:<line number>: PASSED:
-with message:
- !(sr1.empty())
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- sr1.size() == 3
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- sr2.empty()
-
-String.tests.cpp:<line number>: PASSED:
-with message:
- sr2.size() == 0
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
+with expansion:
+ 4 > 0
-------------------------------------------------------------------------------
-Stringifying char arrays with statically known sizes - char
+Template test case with test types specified inside std::tuple - MyTypes - 0
-------------------------------------------------------------------------------
-ToString.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
-with expansion:
- ""abc"" == ""abc""
-
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- ""abc"" == ""abc""
+ 4 > 0
-------------------------------------------------------------------------------
-Stringifying char arrays with statically known sizes - signed char
+Template test case with test types specified inside std::tuple - MyTypes - 1
-------------------------------------------------------------------------------
-ToString.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
-with expansion:
- ""abc"" == ""abc""
-
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- ""abc"" == ""abc""
+ 1 > 0
-------------------------------------------------------------------------------
-Stringifying char arrays with statically known sizes - unsigned char
+Template test case with test types specified inside std::tuple - MyTypes - 2
-------------------------------------------------------------------------------
-ToString.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( with_null_terminator ) == R"("abc")"s )
-with expansion:
- ""abc"" == ""abc""
-
-ToString.tests.cpp:<line number>: PASSED:
- CHECK( ::Catch::Detail::stringify( no_null_terminator ) == R"("abc")"s )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( sizeof(TestType) > 0 )
with expansion:
- ""abc"" == ""abc""
+ 4 > 0
-------------------------------------------------------------------------------
-Stringifying std::chrono::duration helpers
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-ToStringChrono.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( minute == seconds )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 m == 60 s
+ 5 == 5
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( hour != seconds )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- 1 h != 60 s
+ 5 >= 5
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( micro != milli )
+-------------------------------------------------------------------------------
+TemplateTest: vectors can be sized and resized - float
+ resizing bigger changes size and capacity
+-------------------------------------------------------------------------------
+Misc.tests.cpp:<line number>
+...............................................................................
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 10 )
with expansion:
- 1 us != 1 ms
+ 10 == 10
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( nano != micro )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
with expansion:
- 1 ns != 1 us
+ 10 >= 10
-------------------------------------------------------------------------------
-Stringifying std::chrono::duration with weird ratios
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-ToStringChrono.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( half_minute != femto_second )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 [30/1]s != 1 fs
+ 5 == 5
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( pico_second != atto_second )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- 1 ps != 1 as
+ 5 >= 5
-------------------------------------------------------------------------------
-Stringifying std::chrono::time_point<system_clock>
+TemplateTest: vectors can be sized and resized - float
+ resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
-ToStringChrono.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-ToStringChrono.tests.cpp:<line number>: PASSED:
- REQUIRE( now != later )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 0 )
with expansion:
- {iso8601-timestamp}
- !=
- {iso8601-timestamp}
+ 0 == 0
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Tabs and newlines show in output
+TemplateTest: vectors can be sized and resized - float
+ resizing smaller changes size but not capacity
+ We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: FAILED:
- CHECK( s1 == s2 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() == 0 )
with expansion:
- "if ($b == 10) {
- $a = 20;
- }"
- ==
- "if ($b == 10) {
- $a = 20;
- }
- "
+ 0 == 0
-------------------------------------------------------------------------------
-Tag alias can be registered against tag patterns
- The same tag alias can only be registered once
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "[@zzz]" ) )
-with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "[@zzz]"
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "file" ) )
-with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "file"
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "2" ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "2"
+ 5 == 5
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THAT( what, ContainsSubstring( "10" ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- "error: tag alias, '[@zzz]' already registered.
- First seen at: file:2
- Redefined at: file:10" contains: "10"
+ 5 >= 5
-------------------------------------------------------------------------------
-Tag alias can be registered against tag patterns
- Tag aliases must be of the form [@name]
+TemplateTest: vectors can be sized and resized - float
+ reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "[no ampersat]", "", Catch::SourceLineInfo( "file", 3 ) ) )
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "[the @ is not at the start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
-
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "@no square bracket at start]", "", Catch::SourceLineInfo( "file", 3 ) ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
+with expansion:
+ 5 == 5
-Tag.tests.cpp:<line number>: PASSED:
- CHECK_THROWS( registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
+with expansion:
+ 10 >= 10
-------------------------------------------------------------------------------
-Tags with spaces and non-alphanumerical characters are accepted
+TemplateTest: vectors can be sized and resized - float
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.tags.size() == 2 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 2 == 2
+ 5 == 5
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( testCase.tags, VectorContains( Tag( "tag with spaces" ) ) && VectorContains( Tag( "I said \"good day\" sir!"_catch_sr ) ) )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
with expansion:
- { {?}, {?} } ( Contains: {?} and Contains: {?} )
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case method with test types specified inside std::tuple - MyTypes
-- 0
+TemplateTest: vectors can be sized and resized - float
+ reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
-Class.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Class.tests.cpp:<line number>: PASSED:
- REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 == 1
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case method with test types specified inside std::tuple - MyTypes
-- 1
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
-Class.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Class.tests.cpp:<line number>: PASSED:
- REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 == 1
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case method with test types specified inside std::tuple - MyTypes
-- 2
+TemplateTest: vectors can be sized and resized - int
+ resizing bigger changes size and capacity
-------------------------------------------------------------------------------
-Class.tests.cpp:<line number>
+Misc.tests.cpp:<line number>
...............................................................................
-Class.tests.cpp:<line number>: PASSED:
- REQUIRE( Template_Fixture<TestType>::m_a == 1 )
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.size() == 10 )
with expansion:
- 1.0 == 1
+ 10 == 10
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
+with expansion:
+ 10 >= 10
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-copyable and non-
-movable std::tuple - NonCopyableAndNonMovableTypes - 0
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-copyable and non-
-movable std::tuple - NonCopyableAndNonMovableTypes - 1
+TemplateTest: vectors can be sized and resized - int
+ resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 0 )
with expansion:
- 4 > 0
+ 0 == 0
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-default-constructible
-std::tuple - MyNonDefaultConstructibleTypes - 0
+TemplateTest: vectors can be sized and resized - int
+ resizing smaller changes size but not capacity
+ We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.capacity() == 0 )
with expansion:
- 1 > 0
+ 0 == 0
-------------------------------------------------------------------------------
-Template test case with test types specified inside non-default-constructible
-std::tuple - MyNonDefaultConstructibleTypes - 1
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 4 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside std::tuple - MyTypes - 0
+TemplateTest: vectors can be sized and resized - int
+ reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 4 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 10 )
+with expansion:
+ 10 >= 10
-------------------------------------------------------------------------------
-Template test case with test types specified inside std::tuple - MyTypes - 1
+TemplateTest: vectors can be sized and resized - int
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 1 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-Template test case with test types specified inside std::tuple - MyTypes - 2
+TemplateTest: vectors can be sized and resized - int
+ reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( sizeof(TestType) > 0 )
+ REQUIRE( v.size() == 5 )
with expansion:
- 4 > 0
+ 5 == 5
+
+Misc.tests.cpp:<line number>: PASSED:
+ REQUIRE( v.capacity() >= 5 )
+with expansion:
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12145,7 +11573,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12162,7 +11590,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12178,7 +11606,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12195,7 +11623,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12208,7 +11636,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12224,7 +11652,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12241,7 +11669,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12257,7 +11685,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - float
+TemplateTest: vectors can be sized and resized - std::string
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12274,7 +11702,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12290,7 +11718,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12307,7 +11735,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12323,7 +11751,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12340,7 +11768,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12353,7 +11781,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12369,7 +11797,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12386,7 +11814,7 @@ with expansion:
10 >= 10
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12402,7 +11830,7 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - int
+TemplateTest: vectors can be sized and resized - std::tuple<int,float>
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12419,56 +11847,56 @@ with expansion:
5 >= 5
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 10 )
+ REQUIRE( v.size() == 2 * V )
with expansion:
- 10 == 10
+ 12 == 12
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 12 >= 12
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12480,12 +11908,12 @@ with expansion:
0 == 0
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12498,122 +11926,122 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 12 >= 12
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::string
+TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 6 == 6
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 6 >= 6
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 10 )
+ REQUIRE( v.size() == 2 * V )
with expansion:
- 10 == 10
+ 8 == 8
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 8 >= 8
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12625,12 +12053,12 @@ with expansion:
0 == 0
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12643,73 +12071,73 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 10 )
+ REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 10 >= 10
+ 8 >= 8
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTest: vectors can be sized and resized - std::tuple<int,float>
+TemplateTestSig: vectors can be sized and resized - float,4
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 5 )
+ REQUIRE( v.size() == V )
with expansion:
- 5 == 5
+ 4 == 4
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 5 )
+ REQUIRE( v.capacity() >= V )
with expansion:
- 5 >= 5
+ 4 >= 4
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12717,15 +12145,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12734,15 +12162,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == 2 * V )
with expansion:
- 12 == 12
+ 10 == 10
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 12 >= 12
+ 10 >= 10
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12750,15 +12178,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12772,10 +12200,10 @@ with expansion:
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12788,7 +12216,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12796,15 +12224,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12813,15 +12241,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 12 >= 12
+ 10 >= 10
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12829,15 +12257,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6
+TemplateTestSig: vectors can be sized and resized - int,5
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12846,15 +12274,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 6 == 6
+ 5 == 5
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 6 >= 6
+ 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12862,15 +12290,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
resizing bigger changes size and capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12879,15 +12307,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == 2 * V )
with expansion:
- 8 == 8
+ 30 == 30
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 8 >= 8
+ 30 >= 30
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12895,15 +12323,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
resizing smaller changes size but not capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12917,10 +12345,10 @@ with expansion:
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
resizing smaller changes size but not capacity
We can use the 'swap trick' to reset the capacity
-------------------------------------------------------------------------------
@@ -12933,7 +12361,7 @@ with expansion:
0 == 0
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12941,15 +12369,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
reserving bigger changes capacity but not size
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12958,15 +12386,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= 2 * V )
with expansion:
- 8 >= 8
+ 30 >= 30
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
@@ -12974,15 +12402,15 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - float,4
+TemplateTestSig: vectors can be sized and resized - std::string,15
reserving smaller does not change size or capacity
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
@@ -12991,527 +12419,604 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.size() == V )
with expansion:
- 4 == 4
+ 15 == 15
Misc.tests.cpp:<line number>: PASSED:
REQUIRE( v.capacity() >= V )
with expansion:
- 4 >= 4
+ 15 >= 15
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+Test case with identical tags keeps just one
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Tag.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.tags.size() == 1 )
with expansion:
- 5 == 5
+ 1 == 1
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+Tag.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.tags[0] == Tag( "tag1" ) )
with expansion:
- 5 >= 5
+ {?} == {?}
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- resizing bigger changes size and capacity
+Test case with one argument
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+VariadicMacros.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 2 * V )
-with expansion:
- 10 == 10
+VariadicMacros.tests.cpp:<line number>: PASSED:
+with message:
+ no assertions
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+-------------------------------------------------------------------------------
+Test enum bit values
+-------------------------------------------------------------------------------
+Tricky.tests.cpp:<line number>
+...............................................................................
+
+Tricky.tests.cpp:<line number>: PASSED:
+ REQUIRE( 0x<hex digits> == bit30and31 )
with expansion:
- 10 >= 10
+ 3221225472 (0x<hex digits>) == 3221225472
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+Test with special, characters "in name
+-------------------------------------------------------------------------------
+CmdLine.tests.cpp:<line number>
+...............................................................................
+
+CmdLine.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+Testing checked-if
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
-with expansion:
- 5 == 5
+ CHECKED_IF( true )
+
+Misc.tests.cpp:<line number>: PASSED:
+
+Misc.tests.cpp:<line number>: FAILED - but was ok:
+ CHECKED_IF( false )
+
+Misc.tests.cpp:<line number>: PASSED:
+ CHECKED_ELSE( true )
+
+Misc.tests.cpp:<line number>: FAILED - but was ok:
+ CHECKED_ELSE( false )
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- resizing smaller changes size but not capacity
+Testing checked-if 2
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 0 )
-with expansion:
- 0 == 0
+ CHECKED_IF( true )
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
+Misc.tests.cpp:<line number>: FAILED:
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- resizing smaller changes size but not capacity
- We can use the 'swap trick' to reset the capacity
+Testing checked-if 3
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() == 0 )
-with expansion:
- 0 == 0
+Misc.tests.cpp:<line number>: FAILED - but was ok:
+ CHECKED_ELSE( false )
+
+Misc.tests.cpp:<line number>: FAILED:
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+The NO_FAIL macro reports a failure but does not fail the test
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Message.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
-with expansion:
- 5 == 5
+Message.tests.cpp:<line number>: FAILED - but was ok:
+ CHECK_NOFAIL( 1 == 2 )
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
+
+No assertions in test case 'The NO_FAIL macro reports a failure but does not fail the test'
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- reserving bigger changes capacity but not size
+The default listing implementation write to provided stream
+ Listing tags
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Reporters.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring("[fakeTag]"s) )
with expansion:
- 5 == 5
+ "All available tags:
+ 1 [fakeTag]
+ 1 tag
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+" contains: "[fakeTag]"
+
+-------------------------------------------------------------------------------
+The default listing implementation write to provided stream
+ Listing reporters
+-------------------------------------------------------------------------------
+Reporters.tests.cpp:<line number>
+...............................................................................
+
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring( "fake reporter"s ) && ContainsSubstring( "fake description"s ) )
with expansion:
- 10 >= 10
+ "Available reporters:
+ fake reporter: fake description
+
+" ( contains: "fake reporter" and contains: "fake description" )
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
+The default listing implementation write to provided stream
+ Listing tests
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+Reporters.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) )
with expansion:
- 5 == 5
+ "All available test cases:
+ fake test name
+ [fakeTestTag]
+ 1 test case
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+" ( contains: "fake test name" and contains: "fakeTestTag" )
+
+-------------------------------------------------------------------------------
+The default listing implementation write to provided stream
+ Listing listeners
+-------------------------------------------------------------------------------
+Reporters.tests.cpp:<line number>
+...............................................................................
+
+Reporters.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( listingString, ContainsSubstring( "fakeListener"s ) && ContainsSubstring( "fake description"s ) )
with expansion:
- 5 >= 5
+ "Registered listeners:
+ fakeListener: fake description
+
+" ( contains: "fakeListener" and contains: "fake description" )
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - int,5
- reserving smaller does not change size or capacity
+This test 'should' fail but doesn't
-------------------------------------------------------------------------------
Misc.tests.cpp:<line number>
...............................................................................
Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
-with expansion:
- 5 == 5
+with message:
+ oops!
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
-with expansion:
- 5 >= 5
+-------------------------------------------------------------------------------
+Thrown string literals are translated
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
+
+Exception.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ For some reason someone is throwing a string literal!
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
+Tracker
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- resizing bigger changes size and capacity
+Tracker
+ successfully close one section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 2 * V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isSuccessfullyCompleted() )
with expansion:
- 30 == 30
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
with expansion:
- 30 >= 30
-
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+ false == false
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- resizing smaller changes size but not capacity
+Tracker
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == 0 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- 0 == 0
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- resizing smaller changes size but not capacity
- We can use the 'swap trick' to reset the capacity
+Tracker
+ fail one section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() == 0 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isComplete() )
with expansion:
- 0 == 0
-
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isSuccessfullyCompleted() == false )
with expansion:
- 15 == 15
+ false == false
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
with expansion:
- 15 >= 15
-
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- reserving bigger changes capacity but not size
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+ false == false
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= 2 * V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() == false )
with expansion:
- 30 >= 30
+ false == false
-------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
+Tracker
+ fail one section
+ re-enter after failed section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isOpen() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1b.isOpen() == false )
with expansion:
- 15 >= 15
+ false == false
--------------------------------------------------------------------------------
-TemplateTestSig: vectors can be sized and resized - std::string,15
- reserving smaller does not change size or capacity
--------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.size() == V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() )
with expansion:
- 15 == 15
+ true
-Misc.tests.cpp:<line number>: PASSED:
- REQUIRE( v.capacity() >= V )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() )
with expansion:
- 15 >= 15
+ true
-------------------------------------------------------------------------------
-Test case with identical tags keeps just one
+Tracker
-------------------------------------------------------------------------------
-Tag.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.tags.size() == 1 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- 1 == 1
+ true
-Tag.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.tags[0] == Tag( "tag1" ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
with expansion:
- {?} == {?}
+ true
-------------------------------------------------------------------------------
-Test case with one argument
+Tracker
+ fail one section
-------------------------------------------------------------------------------
-VariadicMacros.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-VariadicMacros.tests.cpp:<line number>: PASSED:
-with message:
- no assertions
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isComplete() )
+with expansion:
+ true
--------------------------------------------------------------------------------
-Test enum bit values
--------------------------------------------------------------------------------
-Tricky.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isSuccessfullyCompleted() == false )
+with expansion:
+ false == false
-Tricky.tests.cpp:<line number>: PASSED:
- REQUIRE( 0x<hex digits> == bit30and31 )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
with expansion:
- 3221225472 (0x<hex digits>) == 3221225472
+ false == false
--------------------------------------------------------------------------------
-Test with special, characters "in name
--------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
+with expansion:
+ true
-CmdLine.tests.cpp:<line number>: PASSED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
-Testing checked-if
+Tracker
+ fail one section
+ re-enter after failed section and find next section
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- CHECKED_IF( true )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isOpen() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1b.isOpen() == false )
+with expansion:
+ false == false
-Misc.tests.cpp:<line number>: FAILED - but was ok:
- CHECKED_IF( false )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2.isOpen() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
- CHECKED_ELSE( true )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: FAILED - but was ok:
- CHECKED_ELSE( false )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: PASSED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isSuccessfullyCompleted() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-Testing checked-if 2
+Tracker
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
- CHECKED_IF( true )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
+with expansion:
+ true
-Misc.tests.cpp:<line number>: FAILED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-Testing checked-if 3
+Tracker
+ successfully close one section, then find another
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: FAILED - but was ok:
- CHECKED_ELSE( false )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2.isOpen() == false )
+with expansion:
+ false == false
-Misc.tests.cpp:<line number>: FAILED:
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
-The NO_FAIL macro reports a failure but does not fail the test
+Tracker
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
-------------------------------------------------------------------------------
-Message.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Message.tests.cpp:<line number>: FAILED - but was ok:
- CHECK_NOFAIL( 1 == 2 )
-
-
-No assertions in test case 'The NO_FAIL macro reports a failure but does not fail the test'
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isOpen() )
+with expansion:
+ true
--------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing tags
--------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1b.isOpen() == false )
+with expansion:
+ false == false
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring("[fakeTag]"s) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isOpen() )
with expansion:
- "All available tags:
- 1 [fakeTag]
- 1 tag
+ true
-" contains: "[fakeTag]"
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing reporters
+Tracker
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
+ Successfully close S2
-------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring( "fake reporter"s ) && ContainsSubstring( "fake description"s ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() )
with expansion:
- "Available reporters:
- fake reporter: fake description
-
-" ( contains: "fake reporter" and contains: "fake description" )
+ true
--------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing tests
--------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isSuccessfullyCompleted() )
+with expansion:
+ true
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring( "fake test name"s ) && ContainsSubstring( "fakeTestTag"s ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isComplete() == false )
with expansion:
- "All available test cases:
- fake test name
- [fakeTestTag]
- 1 test case
+ false == false
-" ( contains: "fake test name" and contains: "fakeTestTag" )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase2.isSuccessfullyCompleted() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-The default listing implementation write to provided stream
- Listing listeners
+Tracker
-------------------------------------------------------------------------------
-Reporters.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Reporters.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( listingString, ContainsSubstring( "fakeListener"s ) && ContainsSubstring( "fake description"s ) )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isOpen() )
with expansion:
- "Registered listeners:
- fakeListener: fake description
+ true
-" ( contains: "fakeListener" and contains: "fake description" )
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s1.isOpen() )
+with expansion:
+ true
-------------------------------------------------------------------------------
-This test 'should' fail but doesn't
+Tracker
+ successfully close one section, then find another
-------------------------------------------------------------------------------
-Misc.tests.cpp:<line number>
+PartTracker.tests.cpp:<line number>
...............................................................................
-Misc.tests.cpp:<line number>: PASSED:
-with message:
- oops!
-
--------------------------------------------------------------------------------
-Thrown string literals are translated
--------------------------------------------------------------------------------
-Exception.tests.cpp:<line number>
-...............................................................................
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2.isOpen() == false )
+with expansion:
+ false == false
-Exception.tests.cpp:<line number>: FAILED:
-due to unexpected exception with message:
- For some reason someone is throwing a string literal!
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() == false )
+with expansion:
+ false == false
-------------------------------------------------------------------------------
Tracker
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
-------------------------------------------------------------------------------
PartTracker.tests.cpp:<line number>
...............................................................................
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+ REQUIRE( testCase2.isOpen() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+ REQUIRE( s1b.isOpen() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isOpen() )
with expansion:
true
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( ctx.completedCycle() == false )
+with expansion:
+ false == false
+
-------------------------------------------------------------------------------
Tracker
- successfully close one section
+ successfully close one section, then find another
+ Re-enter - skips S1 and enters S2
+ fail S2
-------------------------------------------------------------------------------
PartTracker.tests.cpp:<line number>
...............................................................................
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isSuccessfullyCompleted() )
+ REQUIRE( ctx.completedCycle() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+ REQUIRE( s2b.isComplete() )
+with expansion:
+ true
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2b.isSuccessfullyCompleted() == false )
with expansion:
false == false
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+ REQUIRE( testCase2.isSuccessfullyCompleted() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase3.isOpen() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() )
+ REQUIRE( s1c.isOpen() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( s2c.isOpen() == false )
+with expansion:
+ false == false
+
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase3.isSuccessfullyCompleted() )
with expansion:
true
@@ -13533,538 +13038,594 @@ with expansion:
-------------------------------------------------------------------------------
Tracker
- fail one section
+ open a nested section
-------------------------------------------------------------------------------
PartTracker.tests.cpp:<line number>
...............................................................................
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() )
+ REQUIRE( s2.isOpen() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isSuccessfullyCompleted() == false )
+ REQUIRE( s2.isComplete() )
with expansion:
- false == false
+ true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+ REQUIRE( s1.isComplete() == false )
with expansion:
false == false
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+ REQUIRE( s1.isComplete() )
with expansion:
true
PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() == false )
+ REQUIRE( testCase.isComplete() == false )
with expansion:
false == false
+PartTracker.tests.cpp:<line number>: PASSED:
+ REQUIRE( testCase.isComplete() )
+with expansion:
+ true
+
-------------------------------------------------------------------------------
-Tracker
- fail one section
- re-enter after failed section
+Trim strings
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+StringManip.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(no_whitespace)) == no_whitespace )
with expansion:
- true
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(leading_whitespace)) == no_whitespace )
+with expansion:
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
+
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(trailing_whitespace)) == no_whitespace )
+with expansion:
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
+
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(std::string(whitespace_at_both_ends)) == no_whitespace )
+with expansion:
+ "There is no extra whitespace here"
+ ==
+ "There is no extra whitespace here"
+
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(no_whitespace)) == StringRef(no_whitespace) )
with expansion:
- false == false
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(leading_whitespace)) == StringRef(no_whitespace) )
with expansion:
- true
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) )
with expansion:
- true
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() )
+StringManip.tests.cpp:<line number>: PASSED:
+ REQUIRE( trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) )
with expansion:
- true
+ There is no extra whitespace here
+ ==
+ There is no extra whitespace here
-------------------------------------------------------------------------------
-Tracker
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers of different container types
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, RangeEquals( c_array ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( c_array ) )
with expansion:
- true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Tracker
- fail one section
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers of different container types (differ in array N)
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_3, !RangeEquals( array_int_4 ) )
with expansion:
- true
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isSuccessfullyCompleted() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_3, !UnorderedRangeEquals( array_int_4 ) )
with expansion:
- false == false
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers of different container types and value types
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, RangeEquals( vector_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
- false == false
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Tracker
- fail one section
- re-enter after failed section and find next section
+Type conversions of RangeEquals and similar
+ Container conversions
+ Two equal containers, one random access, one not
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
-with expansion:
- true
+MatchersRanges.tests.cpp:<line number>: PASSED:
+with message:
+ ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess(
+ list_char_a )
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, RangeEquals( list_char_a ) )
with expansion:
- false == false
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( list_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Type conversions of RangeEquals and similar
+ Value type
+ Two equal containers of different value types
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, RangeEquals( vector_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isSuccessfullyCompleted() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, UnorderedRangeEquals( vector_char_a ) )
with expansion:
- true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Tracker
+Type conversions of RangeEquals and similar
+ Value type
+ Two non-equal containers of different value types
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, !RangeEquals( vector_char_b ) )
with expansion:
- true
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_int_a, !UnorderedRangeEquals( vector_char_b ) )
with expansion:
- true
+ { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
+Type conversions of RangeEquals and similar
+ Ranges with begin that needs ADL
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( a, !RangeEquals( b ) )
with expansion:
- false == false
+ { 1, 2, 3 } not elements are { 3, 2, 1 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( a, UnorderedRangeEquals( b ) )
with expansion:
- false == false
+ { 1, 2, 3 } unordered elements are { 3, 2, 1 }
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
+Type conversions of RangeEquals and similar
+ Custom predicate
+ Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_a, RangeEquals( array_a_plus_1, close_enough ) )
with expansion:
- true
+ { 1, 2, 3 } elements are { 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) )
with expansion:
- false == false
+ { 1, 2, 3 } unordered elements are { 2, 3, 4 }
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isOpen() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Unexpected exceptions can be translated
+-------------------------------------------------------------------------------
+Exception.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() == false )
-with expansion:
- false == false
+Exception.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ 3.14
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
- Successfully close S2
+Upcasting special member functions
+ Move constructor
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+UniquePtr.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
-with expansion:
- true
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isSuccessfullyCompleted() )
+UniquePtr.tests.cpp:<line number>: PASSED:
+ REQUIRE( bptr->i == 3 )
with expansion:
- true
+ 3 == 3
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isComplete() == false )
-with expansion:
- false == false
+-------------------------------------------------------------------------------
+Upcasting special member functions
+ move assignment
+-------------------------------------------------------------------------------
+UniquePtr.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isSuccessfullyCompleted() )
+UniquePtr.tests.cpp:<line number>: PASSED:
+ REQUIRE( bptr->i == 3 )
with expansion:
- true
+ 3 == 3
-------------------------------------------------------------------------------
-Tracker
+Usage of AllMatch range matcher
+ Basic usage
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllMatch(SizeIs(5)) )
with expansion:
- true
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
+ }, { 1, 0, 0, -1, 5 } } all match has size == 5
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllMatch(Contains(0) && Contains(1)) )
with expansion:
- true
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
+ }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains
+ element 1 )
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
+Usage of AllMatch range matcher
+ Type requires ADL found begin and end
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() == false )
-with expansion:
- false == false
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( needs_adl, AllMatch( Predicate<int>( []( int elem ) { return elem < 6; } ) ) )
with expansion:
- false == false
+ { 1, 2, 3, 4, 5 } all match matches undescribed predicate
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
+Usage of AllMatch range matcher
+ Shortcircuiting
+ All are read
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, allMatch )
+with expansion:
+ { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1b.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
- false == false
+ true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
+with expansion:
+ true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[3] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[4] )
with expansion:
- false == false
+ true
-------------------------------------------------------------------------------
-Tracker
- successfully close one section, then find another
- Re-enter - skips S1 and enters S2
- fail S2
+Usage of AllMatch range matcher
+ Shortcircuiting
+ Short-circuited
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( ctx.completedCycle() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, !allMatch )
with expansion:
- true
+ { 1, 2, 3, 4, 5 } not all match matches undescribed predicate
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isComplete() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2b.isSuccessfullyCompleted() == false )
-with expansion:
- false == false
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase2.isSuccessfullyCompleted() == false )
-with expansion:
- false == false
-
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase3.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1c.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
with expansion:
- false == false
+ true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2c.isOpen() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[3] )
with expansion:
- false == false
+ !false
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase3.isSuccessfullyCompleted() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[4] )
with expansion:
- true
+ !false
-------------------------------------------------------------------------------
-Tracker
+Usage of AllTrue range matcher
+ Basic usage
+ All true evaluates to true
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllTrue() )
with expansion:
- true
+ { true, true, true, true, true } contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isOpen() )
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Basic usage
+ Empty evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllTrue() )
with expansion:
- true
+ { } contains only true
-------------------------------------------------------------------------------
-Tracker
- open a nested section
+Usage of AllTrue range matcher
+ Basic usage
+ One false evaluates to false
-------------------------------------------------------------------------------
-PartTracker.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isOpen() )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- true
+ { true, true, false, true, true } not contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s2.isComplete() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Basic usage
+ All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- false == false
+ { false, false, false, false, false } not contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( s1.isComplete() )
-with expansion:
- true
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Contained type is convertible to bool
+ All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() == false )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, AllTrue() )
with expansion:
- false == false
+ { true, true, true, true, true } contains only true
-PartTracker.tests.cpp:<line number>: PASSED:
- REQUIRE( testCase.isComplete() )
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Contained type is convertible to bool
+ One false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- true
+ { true, true, false, true, true } not contains only true
-------------------------------------------------------------------------------
-Trim strings
+Usage of AllTrue range matcher
+ Contained type is convertible to bool
+ All false evaluates to false
-------------------------------------------------------------------------------
-StringManip.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(no_whitespace)) == no_whitespace )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( data, !AllTrue() )
with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+ { false, false, false, false, false } not contains only true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(leading_whitespace)) == no_whitespace )
-with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+ Shortcircuiting
+ All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(trailing_whitespace)) == no_whitespace )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, AllTrue() )
with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+ { true, true, true, true, true } contains only true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(std::string(whitespace_at_both_ends)) == no_whitespace )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
with expansion:
- "There is no extra whitespace here"
- ==
- "There is no extra whitespace here"
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(no_whitespace)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(leading_whitespace)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[3] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-StringManip.tests.cpp:<line number>: PASSED:
- REQUIRE( trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[4] )
with expansion:
- There is no extra whitespace here
- ==
- There is no extra whitespace here
+ true
-------------------------------------------------------------------------------
-Unexpected exceptions can be translated
+Usage of AllTrue range matcher
+ Shortcircuiting
+ Short-circuited
-------------------------------------------------------------------------------
-Exception.tests.cpp:<line number>
+MatchersRanges.tests.cpp:<line number>
...............................................................................
-Exception.tests.cpp:<line number>: FAILED:
-due to unexpected exception with message:
- 3.14
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_THAT( mocked, !AllTrue() )
+with expansion:
+ { true, true, false, true, true } not contains only true
--------------------------------------------------------------------------------
-Upcasting special member functions
- Move constructor
--------------------------------------------------------------------------------
-UniquePtr.tests.cpp:<line number>
-...............................................................................
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[0] )
+with expansion:
+ true
-UniquePtr.tests.cpp:<line number>: PASSED:
- REQUIRE( bptr->i == 3 )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[1] )
with expansion:
- 3 == 3
+ true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE( mocked.m_derefed[2] )
+with expansion:
+ true
--------------------------------------------------------------------------------
-Upcasting special member functions
- move assignment
--------------------------------------------------------------------------------
-UniquePtr.tests.cpp:<line number>
-...............................................................................
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+ !false
-UniquePtr.tests.cpp:<line number>: PASSED:
- REQUIRE( bptr->i == 3 )
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked.m_derefed[4] )
with expansion:
- 3 == 3
+ !false
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Basic usage
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllMatch(SizeIs(5)) )
+ REQUIRE_THAT( data, AnyMatch(SizeIs(5)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } all match has size == 5
+ }, { 1, 0, 0, -1, 5 } } any match has size == 5
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllMatch(Contains(0) && Contains(1)) )
+ REQUIRE_THAT( data, !AnyMatch(Contains(0) && Contains(10)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains
- element 1 )
+ }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains
+ element 10 )
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Type requires ADL found begin and end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( needs_adl, AllMatch( Predicate<int>( []( int elem ) { return elem < 6; } ) ) )
+ REQUIRE_THAT( needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) )
with expansion:
- { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } any match matches undescribed predicate
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14072,9 +13633,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, allMatch )
+ REQUIRE_THAT( mocked, !anyMatch )
with expansion:
- { 1, 2, 3, 4, 5 } all match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14102,7 +13663,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AllMatch range matcher
+Usage of AnyMatch range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14110,9 +13671,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !allMatch )
+ REQUIRE_THAT( mocked, anyMatch )
with expansion:
- { 1, 2, 3, 4, 5 } not all match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } any match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14120,14 +13681,14 @@ with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
+ REQUIRE_FALSE( mocked.m_derefed[1] )
with expansion:
- true
+ !false
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
+ REQUIRE_FALSE( mocked.m_derefed[2] )
with expansion:
- true
+ !false
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( mocked.m_derefed[3] )
@@ -14140,7 +13701,7 @@ with expansion:
!false
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
All true evaluates to true
-------------------------------------------------------------------------------
@@ -14148,38 +13709,38 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, true, true, true } contains only true
+ { true, true, true, true, true } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
- Empty evaluates to true
+ Empty evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllTrue() )
+ REQUIRE_THAT( data, !AnyTrue() )
with expansion:
- { } contains only true
+ { } not contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
- One false evalutes to false
+ One true evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, false, true, true } not contains only true
+ { false, false, true, false, false } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Basic usage
All false evaluates to false
-------------------------------------------------------------------------------
@@ -14187,12 +13748,12 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, !AnyTrue() )
with expansion:
- { false, false, false, false, false } not contains only true
+ { false, false, false, false, false } not contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Contained type is convertible to bool
All true evaluates to true
-------------------------------------------------------------------------------
@@ -14200,25 +13761,25 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, true, true, true } contains only true
+ { true, true, true, true, true } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Contained type is convertible to bool
- One false evalutes to false
+ One true evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, AnyTrue() )
with expansion:
- { true, true, false, true, true } not contains only true
+ { false, false, true, false, false } contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Contained type is convertible to bool
All false evaluates to false
-------------------------------------------------------------------------------
@@ -14226,12 +13787,12 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AllTrue() )
+ REQUIRE_THAT( data, !AnyTrue() )
with expansion:
- { false, false, false, false, false } not contains only true
+ { false, false, false, false, false } not contains at least one true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14239,9 +13800,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, AllTrue() )
+ REQUIRE_THAT( mocked, AnyTrue() )
with expansion:
- { true, true, true, true, true } contains only true
+ { false, false, false, false, true } contains at least one true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14269,7 +13830,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AllTrue range matcher
+Usage of AnyTrue range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14277,9 +13838,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !AllTrue() )
+ REQUIRE_THAT( mocked, AnyTrue() )
with expansion:
- { true, true, false, true, true } not contains only true
+ { false, false, true, true, true } contains at least one true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14307,39 +13868,39 @@ with expansion:
!false
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Basic usage
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyMatch(SizeIs(5)) )
+ REQUIRE_THAT( data, NoneMatch(SizeIs(6)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } any match has size == 5
+ }, { 1, 0, 0, -1, 5 } } none match has size == 6
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyMatch(Contains(0) && Contains(10)) )
+ REQUIRE_THAT( data, !NoneMatch(Contains(0) && Contains(1)) )
with expansion:
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains
- element 10 )
+ }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains
+ element 1 )
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Type requires ADL found begin and end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) )
+ REQUIRE_THAT( needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) )
with expansion:
- { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14347,9 +13908,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !anyMatch )
+ REQUIRE_THAT( mocked, noneMatch )
with expansion:
- { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14377,7 +13938,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AnyMatch range matcher
+Usage of NoneMatch range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14385,9 +13946,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, anyMatch )
+ REQUIRE_THAT( mocked, !noneMatch )
with expansion:
- { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14415,98 +13976,98 @@ with expansion:
!false
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- All true evaluates to true
+ All true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { true, true, true, true, true } contains at least one true
+ { true, true, true, true, true } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- Empty evaluates to false
+ Empty evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyTrue() )
+ REQUIRE_THAT( data, NoneTrue() )
with expansion:
- { } not contains at least one true
+ { } contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- One true evalutes to true
+ One true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { false, false, true, false, false } contains at least one true
+ { false, false, true, false, false } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Basic usage
- All false evaluates to false
+ All false evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyTrue() )
+ REQUIRE_THAT( data, NoneTrue() )
with expansion:
- { false, false, false, false, false } not contains at least one true
+ { false, false, false, false, false } contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Contained type is convertible to bool
- All true evaluates to true
+ All true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { true, true, true, true, true } contains at least one true
+ { true, true, true, true, true } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Contained type is convertible to bool
- One true evalutes to true
+ One true evaluates to false
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, AnyTrue() )
+ REQUIRE_THAT( data, !NoneTrue() )
with expansion:
- { false, false, true, false, false } contains at least one true
+ { false, false, true, false, false } not contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Contained type is convertible to bool
- All false evaluates to false
+ All false evaluates to true
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !AnyTrue() )
+ REQUIRE_THAT( data, NoneTrue() )
with expansion:
- { false, false, false, false, false } not contains at least one true
+ { false, false, false, false, false } contains no true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Shortcircuiting
All are read
-------------------------------------------------------------------------------
@@ -14514,9 +14075,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, AnyTrue() )
+ REQUIRE_THAT( mocked, NoneTrue() )
with expansion:
- { false, false, false, false, true } contains at least one true
+ { false, false, false, false, false } contains no true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14544,7 +14105,7 @@ with expansion:
true
-------------------------------------------------------------------------------
-Usage of AnyTrue range matcher
+Usage of NoneTrue range matcher
Shortcircuiting
Short-circuited
-------------------------------------------------------------------------------
@@ -14552,9 +14113,9 @@ MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, AnyTrue() )
+ REQUIRE_THAT( mocked, !NoneTrue() )
with expansion:
- { false, false, true, true, true } contains at least one true
+ { false, false, true, true, true } not contains no true
MatchersRanges.tests.cpp:<line number>: PASSED:
REQUIRE( mocked.m_derefed[0] )
@@ -14582,279 +14143,322 @@ with expansion:
!false
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
+Usage of RangeEquals range matcher
+ Basic usage
+ Empty container matches empty container
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( empty_vector, RangeEquals( empty_vector ) )
+with expansion:
+ { } elements are { }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Empty container does not match non-empty container
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( empty_vector, !RangeEquals( non_empty_vector ) )
+with expansion:
+ { } not elements are { 1 }
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( non_empty_vector, !RangeEquals( empty_vector ) )
+with expansion:
+ { 1 } not elements are { }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Two equal 1-length non-empty containers
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( non_empty_array, RangeEquals( non_empty_array ) )
+with expansion:
+ { 1 } elements are { 1 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Two equal-sized, equal, non-empty containers
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_a, RangeEquals( array_a ) )
+with expansion:
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Basic usage
+ Two equal-sized, non-equal, non-empty containers
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_a, !RangeEquals( array_b ) )
+with expansion:
+ { 1, 2, 3 } not elements are { 2, 2, 3 }
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( array_a, !RangeEquals( array_c ) )
+with expansion:
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
Basic usage
+ Two non-equal-sized, non-empty containers (with same first elements)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneMatch(SizeIs(6)) )
+ CHECK_THAT( vector_a, !RangeEquals( vector_b ) )
with expansion:
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } none match has size == 6
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Custom predicate
+ Two equal non-empty containers (close enough)
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneMatch(Contains(0) && Contains(1)) )
+ CHECK_THAT( vector_a, RangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0
- }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains
- element 1 )
+ { 1, 2, 3 } elements are { 2, 3, 4 }
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
- Type requires ADL found begin and end
+Usage of RangeEquals range matcher
+ Custom predicate
+ Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) )
+ CHECK_THAT( vector_a, !RangeEquals( vector_b, close_enough ) )
with expansion:
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ { 1, 2, 3 } not elements are { 3, 3, 4 }
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
- Shortcircuiting
- All are read
+Usage of RangeEquals range matcher
+ Ranges that need ADL begin/end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, noneMatch )
+ REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl2 ) )
with expansion:
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
+ REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) )
with expansion:
- true
+ { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+
+-------------------------------------------------------------------------------
+Usage of RangeEquals range matcher
+ Check short-circuiting behaviour
+ Check short-circuits on failure
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
+ REQUIRE_THAT( mocked1, !RangeEquals( arr ) )
with expansion:
- true
+ { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
+ REQUIRE( mocked1.m_derefed[0] )
with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[3] )
+ REQUIRE( mocked1.m_derefed[1] )
with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[4] )
+ REQUIRE( mocked1.m_derefed[2] )
with expansion:
true
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ REQUIRE_FALSE( mocked1.m_derefed[3] )
+with expansion:
+ !false
+
-------------------------------------------------------------------------------
-Usage of NoneMatch range matcher
- Shortcircuiting
- Short-circuited
+Usage of RangeEquals range matcher
+ Check short-circuiting behaviour
+ All elements are checked on success
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !noneMatch )
+ REQUIRE_THAT( mocked1, RangeEquals( arr ) )
with expansion:
- { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
+ { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
+ REQUIRE( mocked1.m_derefed[0] )
with expansion:
true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[1] )
-with expansion:
- !false
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[2] )
+ REQUIRE( mocked1.m_derefed[1] )
with expansion:
- !false
+ true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[3] )
+ REQUIRE( mocked1.m_derefed[2] )
with expansion:
- !false
+ true
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[4] )
+ REQUIRE( mocked1.m_derefed[3] )
with expansion:
- !false
+ true
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- All true evaluates to false
+ Empty container matches empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( empty_vector, UnorderedRangeEquals( empty_vector ) )
with expansion:
- { true, true, true, true, true } not contains no true
+ { } unordered elements are { }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- Empty evaluates to true
+ Empty container does not match non-empty container
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneTrue() )
+ CHECK_THAT( empty_vector, !UnorderedRangeEquals( non_empty_vector ) )
with expansion:
- { } contains no true
+ { } not unordered elements are { 1 }
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+ CHECK_THAT( non_empty_vector, !UnorderedRangeEquals( empty_vector ) )
+with expansion:
+ { 1 } not unordered elements are { }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- One true evalutes to false
+ Two equal 1-length non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( non_empty_array, UnorderedRangeEquals( non_empty_array ) )
with expansion:
- { false, false, true, false, false } not contains no true
+ { 1 } unordered elements are { 1 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
+Usage of UnorderedRangeEquals range matcher
Basic usage
- All false evaluates to true
+ Two equal-sized, equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneTrue() )
+ CHECK_THAT( array_a, UnorderedRangeEquals( array_a ) )
with expansion:
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Contained type is convertible to bool
- All true evaluates to false
+Usage of UnorderedRangeEquals range matcher
+ Basic usage
+ Two equal-sized, non-equal, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( array_a, !UnorderedRangeEquals( array_b ) )
with expansion:
- { true, true, true, true, true } not contains no true
+ { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Contained type is convertible to bool
- One true evalutes to false
+Usage of UnorderedRangeEquals range matcher
+ Basic usage
+ Two non-equal-sized, non-empty containers
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, !NoneTrue() )
+ CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b ) )
with expansion:
- { false, false, true, false, false } not contains no true
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Contained type is convertible to bool
- All false evaluates to true
+Usage of UnorderedRangeEquals range matcher
+ Custom predicate
+ Two equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( data, NoneTrue() )
+ CHECK_THAT( vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) )
with expansion:
- { false, false, false, false, false } contains no true
+ { 1, 10, 20 } unordered elements are { 11, 21, 2 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Shortcircuiting
- All are read
+Usage of UnorderedRangeEquals range matcher
+ Custom predicate
+ Two non-equal non-empty containers (close enough)
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, NoneTrue() )
-with expansion:
- { false, false, false, false, false } contains no true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[3] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[4] )
+ CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b, close_enough ) )
with expansion:
- true
+ { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
-------------------------------------------------------------------------------
-Usage of NoneTrue range matcher
- Shortcircuiting
- Short-circuited
+Usage of UnorderedRangeEquals range matcher
+ Ranges that need ADL begin/end
-------------------------------------------------------------------------------
MatchersRanges.tests.cpp:<line number>
...............................................................................
MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_THAT( mocked, !NoneTrue() )
-with expansion:
- { false, false, true, true, true } not contains no true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[0] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[1] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE( mocked.m_derefed[2] )
-with expansion:
- true
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[3] )
-with expansion:
- !false
-
-MatchersRanges.tests.cpp:<line number>: PASSED:
- REQUIRE_FALSE( mocked.m_derefed[4] )
+ REQUIRE_THAT( needs_adl1, UnorderedRangeEquals( needs_adl2 ) )
with expansion:
- !false
+ { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
-------------------------------------------------------------------------------
Usage of the SizeIs range matcher
@@ -15558,6 +15162,16 @@ with expansion:
<Element1 attr1="true" attr2="false"/>
" ( contains: "attr1="true"" and contains: "attr2="false"" )
+-------------------------------------------------------------------------------
+a succeeding test can still be skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
analyse no analysis
-------------------------------------------------------------------------------
@@ -16103,6 +15717,34 @@ FloatingPoint.tests.cpp:<line number>: PASSED:
with expansion:
1 == 1
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 41
+
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+dynamic skipping works with generators
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 43
+
-------------------------------------------------------------------------------
empty tags are not allowed
-------------------------------------------------------------------------------
@@ -16178,6 +15820,67 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
+-------------------------------------------------------------------------------
+failed assertions before SKIP cause test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+ CHECK( 3 == 4 )
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
+-------------------------------------------------------------------------------
+failing for some generator values causes entire test case to fail
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing in some unskipped sections causes entire test case to fail
+ skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+failing in some unskipped sections causes entire test case to fail
+ not skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: FAILED:
+
-------------------------------------------------------------------------------
first tag
-------------------------------------------------------------------------------
@@ -16673,6 +16376,37 @@ Misc.tests.cpp:<line number>: PASSED:
with expansion:
1 != 2
+-------------------------------------------------------------------------------
+nested sections can be skipped dynamically at runtime
+ A
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'A'
+
+-------------------------------------------------------------------------------
+nested sections can be skipped dynamically at runtime
+ B
+ B1
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+
+No assertions in section 'B1'
+
+-------------------------------------------------------------------------------
+nested sections can be skipped dynamically at runtime
+ B
+ B2
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
non streamable - with conv. op
-------------------------------------------------------------------------------
@@ -17274,6 +17008,33 @@ Misc.tests.cpp:<line number>
No assertions in test case 'second tag'
+-------------------------------------------------------------------------------
+sections can be skipped dynamically at runtime
+ not skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
+-------------------------------------------------------------------------------
+sections can be skipped dynamically at runtime
+ skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
+-------------------------------------------------------------------------------
+sections can be skipped dynamically at runtime
+ also not skipped
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: PASSED:
+
-------------------------------------------------------------------------------
send a single char to INFO
-------------------------------------------------------------------------------
@@ -17308,6 +17069,16 @@ Tag.tests.cpp:<line number>: PASSED:
with expansion:
{ {?}, {?} } ( Contains: {?} and Contains: {?} )
+-------------------------------------------------------------------------------
+skipped tests can optionally provide a reason
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+explicitly with message:
+ skipping because answer = 43
+
-------------------------------------------------------------------------------
splitString
-------------------------------------------------------------------------------
@@ -17735,6 +17506,14 @@ Tag.tests.cpp:<line number>: PASSED:
with expansion:
magic.tag == magic.tag
+-------------------------------------------------------------------------------
+tests can be skipped dynamically at runtime
+-------------------------------------------------------------------------------
+Skip.tests.cpp:<line number>
+...............................................................................
+
+Skip.tests.cpp:<line number>: SKIPPED:
+
-------------------------------------------------------------------------------
thrown std::strings are translated
-------------------------------------------------------------------------------
@@ -18442,6 +18221,6 @@ Misc.tests.cpp:<line number>
Misc.tests.cpp:<line number>: PASSED:
===============================================================================
-test cases: 394 | 304 passed | 83 failed | 7 failed as expected
-assertions: 2299 | 2129 passed | 143 failed | 27 failed as expected
+test cases: 409 | 308 passed | 84 failed | 6 skipped | 11 failed as expected
+assertions: 2225 | 2048 passed | 145 failed | 32 failed as expected
diff --git a/packages/Catch2/tests/SelfTest/Baselines/console.swa4.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/console.swa4.approved.txt
index ede2d59ccf17f8d576d2f42646d84a7dfa044e29..41b7612a90d152389939fde40c37cef23481f0f2 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/console.swa4.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/console.swa4.approved.txt
@@ -1,4 +1,4 @@
-Filters: ~[!nonportable]~[!benchmark]~[approvals] *
+Filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
Randomness seeded to: 1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -166,20 +166,20 @@ with expansion:
-------------------------------------------------------------------------------
#1905 -- test spec parser properly clears internal state between compound tests
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase("spec . char")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase("spec , char")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( spec.matches(*fakeTestCase(R"(spec \, char)")) )
with expansion:
!false
@@ -188,20 +188,20 @@ with expansion:
#1912 -- test spec parser handles escaping
Various parentheses
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec {a} char)")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec [a] char)")) )
with expansion:
true
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE_FALSE( spec.matches(*fakeTestCase("differs but has similar tag", "[a]")) )
with expansion:
!false
@@ -210,10 +210,10 @@ with expansion:
#1912 -- test spec parser handles escaping
backslash in test name
-------------------------------------------------------------------------------
-CmdLine.tests.cpp:<line number>
+TestSpec.tests.cpp:<line number>
...............................................................................
-CmdLine.tests.cpp:<line number>: PASSED:
+TestSpec.tests.cpp:<line number>: PASSED:
REQUIRE( spec.matches(*fakeTestCase(R"(spec \ char)")) )
with expansion:
true
@@ -761,6 +761,16 @@ with expansion:
0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.
00000000e+00])
+-------------------------------------------------------------------------------
+#2615 - Throwing in constructor generator fails test case but does not abort
+-------------------------------------------------------------------------------
+Generators.tests.cpp:<line number>
+...............................................................................
+
+Generators.tests.cpp:<line number>: FAILED:
+due to unexpected exception with message:
+ failure to init
+
-------------------------------------------------------------------------------
#748 - captures with unexpected exceptions
outside assertions
@@ -941,6 +951,6 @@ Condition.tests.cpp:<line number>: FAILED:
CHECK( true != true )
===============================================================================
-test cases: 32 | 27 passed | 3 failed | 2 failed as expected
-assertions: 101 | 94 passed | 4 failed | 3 failed as expected
+test cases: 33 | 27 passed | 3 failed | 3 failed as expected
+assertions: 102 | 94 passed | 4 failed | 4 failed as expected
diff --git a/packages/Catch2/tests/SelfTest/Baselines/default.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/default.sw.multi.approved.txt
index 12717aa5f9f952bf9128bbb1dcc76d27196adbbf..bb1748448861e028a0723d770f6d3a4573e77aa8 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/default.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/default.sw.multi.approved.txt
@@ -6,3 +6,6 @@ A string sent to stderr via clog
Message from section one
Message from section two
loose text artifact
+a!
+b1!
+!
diff --git a/packages/Catch2/tests/SelfTest/Baselines/junit.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/junit.sw.approved.txt
index f7411501da435924af1beab2f932c8a6be983a1a..c992154c414f38d1e9d3b0843f4dbd6f81a455a3 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/junit.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/junit.sw.approved.txt
@@ -1,10 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<testsuitesloose text artifact
>
- <testsuite name="<exe-name>" errors="17" failures="126" tests="2299" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+ <testsuite name="<exe-name>" errors="17" failures="128" skipped="12" tests="2237" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
<properties>
<property name="random-seed" value="1"/>
- <property name="filters" value="~[!nonportable]~[!benchmark]~[approvals] *"/>
+ <property name="filters" value=""*" ~[!nonportable] ~[!benchmark] ~[approvals]"/>
</properties>
<testcase classname="<exe-name>.global" name="# A test name that starts with a #" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="#1027: Bitfields can be captured" time="{duration}" status="run"/>
@@ -19,7 +19,7 @@
<failure type="FAIL">
FAILED:
1514
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
<system-out>
This would not be caught previously
@@ -48,13 +48,21 @@ Nor would this
<testcase classname="<exe-name>.global" name="#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="#2152 - ULP checks between differently signed values were wrong - double" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="#2152 - ULP checks between differently signed values were wrong - float" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="#2615 - Throwing in constructor generator fails test case but does not abort" time="{duration}" status="run">
+ <skipped message="TEST_CASE tagged with !mayfail"/>
+ <error type="TEST_CASE">
+FAILED:
+failure to init
+at Generators.tests.cpp:<line number>
+ </error>
+ </testcase>
<testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/outside assertions" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<error type="TEST_CASE">
FAILED:
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/inside REQUIRE_NOTHROW" time="{duration}" status="run">
@@ -64,7 +72,7 @@ FAILED:
REQUIRE_NOTHROW( thisThrows() )
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/inside REQUIRE_THROWS" time="{duration}" status="run"/>
@@ -77,7 +85,7 @@ FAILED:
CHECK( f() == 0 )
with expansion:
1 == 0
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="#872" time="{duration}" status="run"/>
@@ -90,52 +98,52 @@ Misc.tests.cpp:<line number>
<failure message="false != false" type="CHECK">
FAILED:
CHECK( false != false )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="true != true" type="CHECK">
FAILED:
CHECK( true != true )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!true" type="CHECK">
FAILED:
CHECK( !true )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(true)" type="CHECK_FALSE">
FAILED:
CHECK_FALSE( true )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!trueValue" type="CHECK">
FAILED:
CHECK( !trueValue )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(trueValue)" type="CHECK_FALSE">
FAILED:
CHECK_FALSE( trueValue )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(1 == 1)" type="CHECK">
FAILED:
CHECK( !(1 == 1) )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(1 == 1)" type="CHECK_FALSE">
FAILED:
CHECK_FALSE( 1 == 1 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="'Not' checks that should succeed" time="{duration}" status="run"/>
@@ -151,7 +159,7 @@ FAILED:
REQUIRE( s == "world" )
with expansion:
"hello" == "world"
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.TestClass" name="A METHOD_AS_TEST_CASE based test run that succeeds" time="{duration}" status="run"/>
@@ -161,7 +169,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>" time="{duration}" status="run">
@@ -170,7 +178,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>" time="{duration}" status="run">
@@ -179,7 +187,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>" time="{duration}" status="run">
@@ -188,7 +196,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>" time="{duration}" status="run"/>
@@ -201,7 +209,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>" time="{duration}" status="run">
@@ -210,7 +218,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>" time="{duration}" status="run">
@@ -219,7 +227,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>" time="{duration}" status="run">
@@ -228,7 +236,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>" time="{duration}" status="run"/>
@@ -241,7 +249,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture" name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - float" time="{duration}" status="run">
@@ -250,7 +258,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0f == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture" name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - int" time="{duration}" status="run">
@@ -259,7 +267,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture" name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double" time="{duration}" status="run"/>
@@ -271,7 +279,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
1 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Nttp_Fixture" name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3" time="{duration}" status="run">
@@ -280,7 +288,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
3 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Nttp_Fixture" name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6" time="{duration}" status="run">
@@ -289,7 +297,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
6 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Nttp_Fixture" name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1" time="{duration}" status="run"/>
@@ -301,7 +309,7 @@ FAILED:
REQUIRE( m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Fixture" name="A TEST_CASE_METHOD based test run that succeeds" time="{duration}" status="run"/>
@@ -318,7 +326,7 @@ Class.tests.cpp:<line number>
<failure type="FAIL">
FAILED:
to infinity and beyond
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="A couple of nested sections followed by a failure/Outer/Inner" time="{duration}" status="run"/>
@@ -328,14 +336,14 @@ FAILED:
CHECK( &o1 == &o2 )
with expansion:
0x<hex digits> == 0x<hex digits>
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
<failure message="o1 == o2" type="CHECK">
FAILED:
CHECK( o1 == o2 )
with expansion:
{?} == {?}
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Absolute margin" time="{duration}" status="run"/>
@@ -345,7 +353,7 @@ Tricky.tests.cpp:<line number>
FAILED:
{Unknown expression after the reported line}
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Anonymous test case 1" time="{duration}" status="run"/>
@@ -415,14 +423,14 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" contains: "not there" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), ContainsSubstring( "STRING" )" type="CHECK_THAT">
FAILED:
CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )
with expansion:
"this string contains 'abc' as a substring" contains: "STRING"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Copy and then generate a range/from var and iterators" time="{duration}" status="run"/>
@@ -434,7 +442,7 @@ Matchers.tests.cpp:<line number>
FAILED:
REQUIRE_NOTHROW( throwCustom() )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Custom exceptions can be translated when testing for throwing as something else" time="{duration}" status="run">
@@ -442,27 +450,33 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE_THROWS_AS( throwCustom(), std::exception )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Custom std-exceptions can be custom translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
custom std exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Default scale is invisible to comparison" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Directly creating an EnumInfo" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Empty generators can SKIP in constructor" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+This generator is empty
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="Empty stream name opens cout stream" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Empty tag is not allowed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="EndsWith string matcher" time="{duration}" status="run">
<failure message="testStringForMatching(), EndsWith( "Substring" )" type="CHECK_THAT">
FAILED:
CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )
with expansion:
"this string contains 'abc' as a substring" ends with: "Substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No )" type="CHECK_THAT">
FAILED:
@@ -470,7 +484,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" ends with: "this" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Enums can quickly have stringification enabled using REGISTER_ENUM" time="{duration}" status="run"/>
@@ -483,91 +497,91 @@ FAILED:
CHECK( data.int_seven == 6 )
with expansion:
7 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven == 8" type="CHECK">
FAILED:
CHECK( data.int_seven == 8 )
with expansion:
7 == 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven == 0" type="CHECK">
FAILED:
CHECK( data.int_seven == 0 )
with expansion:
7 == 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 9.11f )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.11f ) )
with expansion:
9.1f == Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 9.0f )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.0f ) )
with expansion:
9.1f == Approx( 9.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 1 )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 1 ) )
with expansion:
9.1f == Approx( 1.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 0 )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 0 ) )
with expansion:
9.1f == Approx( 0.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.double_pi == Approx( 3.1415 )" type="CHECK">
FAILED:
CHECK( data.double_pi == Approx( 3.1415 ) )
with expansion:
3.1415926535 == Approx( 3.1415 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello == "goodbye"" type="CHECK">
FAILED:
CHECK( data.str_hello == "goodbye" )
with expansion:
"hello" == "goodbye"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello == "hell"" type="CHECK">
FAILED:
CHECK( data.str_hello == "hell" )
with expansion:
"hello" == "hell"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello == "hello1"" type="CHECK">
FAILED:
CHECK( data.str_hello == "hello1" )
with expansion:
"hello" == "hello1"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello.size() == 6" type="CHECK">
FAILED:
CHECK( data.str_hello.size() == 6 )
with expansion:
5 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="x == Approx( 1.301 )" type="CHECK">
FAILED:
CHECK( x == Approx( 1.301 ) )
with expansion:
1.3 == Approx( 1.301 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Equality checks that should succeed" time="{duration}" status="run"/>
@@ -579,7 +593,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" equals: "this string contains
'ABC' as a substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No )" type="CHECK_THAT">
FAILED:
@@ -587,7 +601,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" equals: "something else" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified" time="{duration}" status="run"/>
@@ -595,12 +609,12 @@ Matchers.tests.cpp:<line number>
<failure message="doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }" type="CHECK_THROWS_MATCHES">
FAILED:
CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }" type="REQUIRE_THROWS_MATCHES">
FAILED:
REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Exception matchers that fail/Type mismatch" time="{duration}" status="run">
@@ -608,13 +622,13 @@ Matchers.tests.cpp:<line number>
FAILED:
CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
<error message="throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }" type="REQUIRE_THROWS_MATCHES">
FAILED:
REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Exception matchers that fail/Contents are wrong" time="{duration}" status="run">
@@ -623,17 +637,18 @@ FAILED:
CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 }" type="REQUIRE_THROWS_MATCHES">
FAILED:
REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Exception matchers that succeed" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Exception message can be matched" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Exception messages can be tested for/exact match" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Exception messages can be tested for/different case" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Exception messages can be tested for/wildcarded" time="{duration}" status="run"/>
@@ -643,53 +658,56 @@ Matchers.tests.cpp:<line number>
FAILED:
CHECK_THROWS_AS( thisThrows(), std::string )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
<failure message="thisDoesntThrow(), std::domain_error" type="CHECK_THROWS_AS">
FAILED:
CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
<error message="thisThrows()" type="CHECK_NOTHROW">
FAILED:
CHECK_NOTHROW( thisThrows() )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="FAIL aborts the test" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="FAIL does not require an argument" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="FAIL_CHECK does not abort the test" time="{duration}" status="run">
<failure type="FAIL_CHECK">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Factorials are computed" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Filter generator throws exception for empty generator" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative/Some subnormal values" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Margin" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/ULPs" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Composed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Constructor validation" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Floating point matchers: double/IsNaN" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative/Some subnormal values" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Margin" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/ULPs" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Composed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Constructor validation" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Floating point matchers: float/IsNaN" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Basic usage" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Throws if there are no matching values" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Generators -- adapters/Shortening a range" time="{duration}" status="run"/>
@@ -743,7 +761,7 @@ with expansion:
2 == 1
this message should be logged
so should this
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="INFO gets logged on failure, even if captured before successful assertions" time="{duration}" status="run">
@@ -754,7 +772,7 @@ with expansion:
2 == 1
this message may be logged later
this message should be logged
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="a == 0" type="CHECK">
FAILED:
@@ -764,7 +782,7 @@ with expansion:
this message may be logged later
this message should be logged
and this, but later
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="INFO is reset for each loop" time="{duration}" status="run">
@@ -775,7 +793,7 @@ with expansion:
10 < 10
current counter 10
i := 10
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Inequality checks that should fail" time="{duration}" status="run">
@@ -785,35 +803,35 @@ FAILED:
CHECK( data.int_seven != 7 )
with expansion:
7 != 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one != Approx( 9.1f )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one != Approx( 9.1f ) )
with expansion:
9.1f != Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.double_pi != Approx( 3.1415926535 )" type="CHECK">
FAILED:
CHECK( data.double_pi != Approx( 3.1415926535 ) )
with expansion:
3.1415926535 != Approx( 3.1415926535 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello != "hello"" type="CHECK">
FAILED:
CHECK( data.str_hello != "hello" )
with expansion:
"hello" != "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello.size() != 5" type="CHECK">
FAILED:
CHECK( data.str_hello.size() != 5 )
with expansion:
5 != 5
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Inequality checks that should succeed" time="{duration}" status="run"/>
@@ -830,7 +848,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" ( ( contains: "string" or
contains: "different" ) and contains: "random" )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Matchers can be negated (Not) with the ! operator" time="{duration}" status="run"/>
@@ -840,35 +858,35 @@ FAILED:
CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )
with expansion:
"this string contains 'abc' as a substring" not contains: "substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/A" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/A" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/B" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/B" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mismatching exception messages failing the test" time="{duration}" status="run">
@@ -877,7 +895,7 @@ FAILED:
REQUIRE_THROWS_WITH( thisThrows(), "should fail" )
with expansion:
"expected exception" equals: "should fail"
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Multireporter calls reporters and listeners in correct order" time="{duration}" status="run"/>
@@ -890,7 +908,7 @@ Exception.tests.cpp:<line number>
<error type="TEST_CASE">
FAILED:
custom exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Objects that evaluated in boolean contexts can be checked" time="{duration}" status="run"/>
@@ -901,133 +919,133 @@ FAILED:
CHECK( data.int_seven > 7 )
with expansion:
7 > 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < 7" type="CHECK">
FAILED:
CHECK( data.int_seven < 7 )
with expansion:
7 < 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven > 8" type="CHECK">
FAILED:
CHECK( data.int_seven > 8 )
with expansion:
7 > 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < 6" type="CHECK">
FAILED:
CHECK( data.int_seven < 6 )
with expansion:
7 < 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < 0" type="CHECK">
FAILED:
CHECK( data.int_seven < 0 )
with expansion:
7 < 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < -1" type="CHECK">
FAILED:
CHECK( data.int_seven < -1 )
with expansion:
7 < -1
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven >= 8" type="CHECK">
FAILED:
CHECK( data.int_seven >= 8 )
with expansion:
7 >= 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven <= 6" type="CHECK">
FAILED:
CHECK( data.int_seven <= 6 )
with expansion:
7 <= 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one < 9" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one < 9 )
with expansion:
9.1f < 9
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one > 10" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one > 10 )
with expansion:
9.1f > 10
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one > 9.2" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one > 9.2 )
with expansion:
9.1f > 9.2
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello > "hello"" type="CHECK">
FAILED:
CHECK( data.str_hello > "hello" )
with expansion:
"hello" > "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello < "hello"" type="CHECK">
FAILED:
CHECK( data.str_hello < "hello" )
with expansion:
"hello" < "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello > "hellp"" type="CHECK">
FAILED:
CHECK( data.str_hello > "hellp" )
with expansion:
"hello" > "hellp"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello > "z"" type="CHECK">
FAILED:
CHECK( data.str_hello > "z" )
with expansion:
"hello" > "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello < "hellm"" type="CHECK">
FAILED:
CHECK( data.str_hello < "hellm" )
with expansion:
"hello" < "hellm"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello < "a"" type="CHECK">
FAILED:
CHECK( data.str_hello < "a" )
with expansion:
"hello" < "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello >= "z"" type="CHECK">
FAILED:
CHECK( data.str_hello >= "z" )
with expansion:
"hello" >= "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello <= "a"" type="CHECK">
FAILED:
CHECK( data.str_hello <= "a" )
with expansion:
"hello" <= "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Ordering comparison checks that should succeed" time="{duration}" status="run"/>
@@ -1037,52 +1055,19 @@ Condition.tests.cpp:<line number>
<failure type="FAIL">
FAILED:
Message from section one
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Output from all sections is reported/two" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
Message from section two
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Overloaded comma or address-of operators are not used" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Empty test spec should have no filters" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from empty string should have no filters" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from just a comma should have no filters" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from name should have one filter" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from quoted name should have one filter" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from name should have one filter" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at the start" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at the end" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at both ends" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Redundant wildcard at the start" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Redundant wildcard at the end" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Redundant wildcard at both ends" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at both ends, redundant at start" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Just wildcard" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Single tag" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Single tag, two matches" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Two tags" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Two tags, spare separated" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcarded name and tag" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Single tag exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/One tag exclusion and one tag inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/One tag exclusion and one wldcarded name inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/One tag exclusion, using exclude:, and one wldcarded name inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/name exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/wildcarded name exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/wildcarded name exclusion with tag inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/wildcarded name exclusion, using exclude:, with tag inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/two wildcarded names" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/empty tag" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/empty quoted name" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/quoted string followed by tag exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Leading and trailing spaces in test spec" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Leading and trailing spaces in test name" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Shortened hide tags are split apart when parsing" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Shortened hide tags also properly handle exclusion" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Parse uints/proper inputs" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Parse uints/Bad inputs" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Parsed tags are matched case insensitive" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/shard-count" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Negative shard count reports error" time="{duration}" status="run"/>
@@ -1146,7 +1131,7 @@ FAILED:
CHECK( truthy(false) )
with expansion:
Hey, its truthy!
-Decomposition.tests.cpp:<line number>
+at Decomposition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Regex string matcher" time="{duration}" status="run">
@@ -1156,7 +1141,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" matches "this STRING contains
'abc' as a substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), Matches( "contains 'abc' as a substring" )" type="CHECK_THAT">
FAILED:
@@ -1164,7 +1149,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" matches "contains 'abc' as a
substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), Matches( "this string contains 'abc' as a" )" type="CHECK_THAT">
FAILED:
@@ -1172,7 +1157,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" matches "this string contains
'abc' as a" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Registering reporter with '::' in name fails" time="{duration}" status="run"/>
@@ -1236,7 +1221,7 @@ FAILED:
CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
with expansion:
"this string contains 'abc' as a substring" starts with: "This String"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No )" type="CHECK_THAT">
FAILED:
@@ -1244,7 +1229,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" starts with: "string" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Single item" time="{duration}" status="run"/>
@@ -1292,7 +1277,7 @@ with expansion:
$a = 20;
}
"
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" time="{duration}" status="run"/>
@@ -1365,14 +1350,14 @@ Misc.tests.cpp:<line number>
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Testing checked-if 3" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="The NO_FAIL macro reports a failure but does not fail the test" time="{duration}" status="run"/>
@@ -1385,7 +1370,7 @@ Misc.tests.cpp:<line number>
<error type="TEST_CASE">
FAILED:
For some reason someone is throwing a string literal!
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Tracker" time="{duration}" status="run"/>
@@ -1399,11 +1384,19 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Tracker/successfully close one section, then find another/Re-enter - skips S1 and enters S2/fail S2" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Tracker/open a nested section" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Trim strings" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Unexpected exceptions can be translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
3.14
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Upcasting special member functions/Move constructor" time="{duration}" status="run"/>
@@ -1414,10 +1407,10 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
@@ -1427,10 +1420,10 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
@@ -1440,13 +1433,33 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>
@@ -1462,7 +1475,7 @@ FAILED:
CHECK_THAT( empty, Approx( t1 ) )
with expansion:
{ } is approx: { 1.0, 2.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector Approx matcher -- failing/Just different vectors" time="{duration}" status="run">
@@ -1471,7 +1484,7 @@ FAILED:
CHECK_THAT( v1, Approx( v2 ) )
with expansion:
{ 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers/Contains (element)" time="{duration}" status="run"/>
@@ -1485,14 +1498,14 @@ FAILED:
CHECK_THAT( v, VectorContains( -1 ) )
with expansion:
{ 1, 2, 3 } Contains: -1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="empty, VectorContains( 1 )" type="CHECK_THAT">
FAILED:
CHECK_THAT( empty, VectorContains( 1 ) )
with expansion:
{ } Contains: 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers that fail/Contains (vector)" time="{duration}" status="run">
@@ -1501,14 +1514,14 @@ FAILED:
CHECK_THAT( empty, Contains( v ) )
with expansion:
{ } Contains: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="v, Contains( v2 )" type="CHECK_THAT">
FAILED:
CHECK_THAT( v, Contains( v2 ) )
with expansion:
{ 1, 2, 3 } Contains: { 1, 2, 4 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers that fail/Equals" time="{duration}" status="run">
@@ -1517,28 +1530,28 @@ FAILED:
CHECK_THAT( v, Equals( v2 ) )
with expansion:
{ 1, 2, 3 } Equals: { 1, 2 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="v2, Equals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( v2, Equals( v ) )
with expansion:
{ 1, 2 } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="empty, Equals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( empty, Equals( v ) )
with expansion:
{ } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="v, Equals( empty )" type="CHECK_THAT">
FAILED:
CHECK_THAT( v, Equals( empty ) )
with expansion:
{ 1, 2, 3 } Equals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers that fail/UnorderedEquals" time="{duration}" status="run">
@@ -1547,28 +1560,28 @@ FAILED:
CHECK_THAT( v, UnorderedEquals( empty ) )
with expansion:
{ 1, 2, 3 } UnorderedEquals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="empty, UnorderedEquals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( empty, UnorderedEquals( v ) )
with expansion:
{ } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="permuted, UnorderedEquals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 1, 3 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="permuted, UnorderedEquals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 3, 1 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="When checked exceptions are thrown they can be expected or unexpected" time="{duration}" status="run"/>
@@ -1576,7 +1589,7 @@ Matchers.tests.cpp:<line number>
<error type="TEST_CASE">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown during a CHECK the test should continue" time="{duration}" status="run">
@@ -1584,7 +1597,7 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown during a REQUIRE the test should abort fail" time="{duration}" status="run">
@@ -1592,7 +1605,7 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown from functions they are always failures" time="{duration}" status="run">
@@ -1600,14 +1613,14 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown from sections they are always failures/section name" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="X/level/0/a" time="{duration}" status="run"/>
@@ -1623,6 +1636,12 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="XmlEncode/string with control char (1)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="XmlEncode/string with control char (x7F)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="XmlWriter writes boolean attributes as true/false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="a succeeding test can still be skipped" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="analyse no analysis" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="array<int, N> -> toString" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="benchmark function call/without chronometer" time="{duration}" status="run"/>
@@ -1635,7 +1654,7 @@ FAILED:
REQUIRE( testCheckedElse( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="checkedIf" time="{duration}" status="run"/>
@@ -1645,7 +1664,7 @@ FAILED:
REQUIRE( testCheckedIf( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="classify_outliers/none" time="{duration}" status="run"/>
@@ -1657,25 +1676,80 @@ Misc.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="comparisons between const int variables" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="comparisons between int variables" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="convertToBits" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="dynamic skipping works with generators" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+skipping because answer = 41
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped type="SKIP">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="empty tags are not allowed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="erfc_inv" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="estimate_clock_resolution" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/d (leaf)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/e (leaf)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="even more nested SECTION tests/f (leaf)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="failed assertions before SKIP cause test case to fail" time="{duration}" status="run">
+ <skipped message="TEST_CASE tagged with !mayfail"/>
+ <failure message="3 == 4" type="CHECK">
+FAILED:
+ CHECK( 3 == 4 )
+at Skip.tests.cpp:<line number>
+ </failure>
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="failing for some generator values causes entire test case to fail" time="{duration}" status="run">
+ <failure type="FAIL">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </failure>
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <failure type="FAIL">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </failure>
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="failing in some unskipped sections causes entire test case to fail/skipped" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="failing in some unskipped sections causes entire test case to fail/not skipped" time="{duration}" status="run">
+ <skipped message="TEST_CASE tagged with !mayfail"/>
+ <failure type="FAIL">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </failure>
+ </testcase>
<testcase classname="<exe-name>.global" name="is_unary_function" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="just failure" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
Previous info should not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="just failure after unscoped info" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
previous unscoped info SHOULD not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="long long" time="{duration}" status="run"/>
@@ -1685,7 +1759,7 @@ FAILED:
CHECK( b > a )
with expansion:
0 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="looped SECTION tests/b is currently: 1" time="{duration}" status="run">
@@ -1694,7 +1768,7 @@ FAILED:
CHECK( b > a )
with expansion:
1 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="looped SECTION tests/b is currently: 2" time="{duration}" status="run"/>
@@ -1712,7 +1786,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[0] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1720,7 +1794,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[1] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1728,7 +1802,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[3] (3) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1736,7 +1810,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[4] (5) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1744,7 +1818,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[6] (13) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1752,7 +1826,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[7] (21) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="makeStream recognizes %debug stream name" time="{duration}" status="run"/>
@@ -1768,13 +1842,26 @@ FAILED:
REQUIRE( a == b )
with expansion:
1 == 2
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/less than" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2/B" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B" time="{duration}" status="run">
+ <system-out>
+a!
+b1!
+!
+ </system-out>
+ </testcase>
<testcase classname="<exe-name>.global" name="non streamable - with conv. op" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="non-copyable objects" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="normal_cdf" time="{duration}" status="run"/>
@@ -1785,7 +1872,7 @@ Misc.tests.cpp:<line number>
FAILED:
REQUIRE( false )
this SHOULD be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="null strings" time="{duration}" status="run"/>
@@ -1802,7 +1889,7 @@ FAILED:
REQUIRE( false )
this SHOULD be seen
this SHOULD also be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="prints unscoped info only for the first assertion" time="{duration}" status="run">
@@ -1810,7 +1897,7 @@ Message.tests.cpp:<line number>
FAILED:
CHECK( false )
this SHOULD be seen only ONCE
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="random SECTION tests/doesn't equal" time="{duration}" status="run"/>
@@ -1826,12 +1913,20 @@ Message.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="resolution" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="run_for_at_least, chronometer" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="run_for_at_least, int" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/not skipped" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/skipped" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/also not skipped" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="send a single char to INFO" time="{duration}" status="run">
<failure message="false" type="REQUIRE">
FAILED:
REQUIRE( false )
3
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="sends information to INFO" time="{duration}" status="run">
@@ -1840,10 +1935,17 @@ FAILED:
REQUIRE( false )
hi
i := 7
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="shortened hide tags are split apart" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="skipped tests can optionally provide a reason" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="splitString" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="stacks unscoped info in loops" time="{duration}" status="run">
<failure message="false" type="CHECK">
@@ -1853,7 +1955,7 @@ Count 1 to 3...
1
2
3
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="false" type="CHECK">
FAILED:
@@ -1862,7 +1964,7 @@ Count 4 to 6...
4
5
6
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="startsWith" time="{duration}" status="run"/>
@@ -1888,11 +1990,17 @@ Message.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="strlen3" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="tables" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="tags with dots in later positions are not parsed as hidden" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="tests can be skipped dynamically at runtime" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="thrown std::strings are translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
Why would you throw a std::string?
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="toString on const wchar_t const pointer returns the string contents" time="{duration}" status="run"/>
@@ -1937,6 +2045,9 @@ This would not be caught previously
A string sent directly to stdout
Message from section one
Message from section two
+a!
+b1!
+!
</system-out>
<system-err>
Nor would this
diff --git a/packages/Catch2/tests/SelfTest/Baselines/junit.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
index aa0860a3c9ac8cae0b873305b50103cf93a29d71..79c3236506da7d2fce43fa4a1db8b6d30ddf3d37 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
@@ -1,9 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<testsuites>
- <testsuite name="<exe-name>" errors="17" failures="126" tests="2299" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+ <testsuite name="<exe-name>" errors="17" failures="128" skipped="12" tests="2237" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
<properties>
<property name="random-seed" value="1"/>
- <property name="filters" value="~[!nonportable]~[!benchmark]~[approvals] *"/>
+ <property name="filters" value=""*" ~[!nonportable] ~[!benchmark] ~[approvals]"/>
</properties>
<testcase classname="<exe-name>.global" name="# A test name that starts with a #" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="#1027: Bitfields can be captured" time="{duration}" status="run"/>
@@ -18,7 +18,7 @@
<failure type="FAIL">
FAILED:
1514
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
<system-out>
This would not be caught previously
@@ -47,13 +47,21 @@ Nor would this
<testcase classname="<exe-name>.global" name="#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="#2152 - ULP checks between differently signed values were wrong - double" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="#2152 - ULP checks between differently signed values were wrong - float" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="#2615 - Throwing in constructor generator fails test case but does not abort" time="{duration}" status="run">
+ <skipped message="TEST_CASE tagged with !mayfail"/>
+ <error type="TEST_CASE">
+FAILED:
+failure to init
+at Generators.tests.cpp:<line number>
+ </error>
+ </testcase>
<testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/outside assertions" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<error type="TEST_CASE">
FAILED:
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/inside REQUIRE_NOTHROW" time="{duration}" status="run">
@@ -63,7 +71,7 @@ FAILED:
REQUIRE_NOTHROW( thisThrows() )
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="#748 - captures with unexpected exceptions/inside REQUIRE_THROWS" time="{duration}" status="run"/>
@@ -76,7 +84,7 @@ FAILED:
CHECK( f() == 0 )
with expansion:
1 == 0
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="#872" time="{duration}" status="run"/>
@@ -89,52 +97,52 @@ Misc.tests.cpp:<line number>
<failure message="false != false" type="CHECK">
FAILED:
CHECK( false != false )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="true != true" type="CHECK">
FAILED:
CHECK( true != true )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!true" type="CHECK">
FAILED:
CHECK( !true )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(true)" type="CHECK_FALSE">
FAILED:
CHECK_FALSE( true )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!trueValue" type="CHECK">
FAILED:
CHECK( !trueValue )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(trueValue)" type="CHECK_FALSE">
FAILED:
CHECK_FALSE( trueValue )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(1 == 1)" type="CHECK">
FAILED:
CHECK( !(1 == 1) )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="!(1 == 1)" type="CHECK_FALSE">
FAILED:
CHECK_FALSE( 1 == 1 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="'Not' checks that should succeed" time="{duration}" status="run"/>
@@ -150,7 +158,7 @@ FAILED:
REQUIRE( s == "world" )
with expansion:
"hello" == "world"
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.TestClass" name="A METHOD_AS_TEST_CASE based test run that succeeds" time="{duration}" status="run"/>
@@ -160,7 +168,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>" time="{duration}" status="run">
@@ -169,7 +177,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>" time="{duration}" status="run">
@@ -178,7 +186,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>" time="{duration}" status="run">
@@ -187,7 +195,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>" time="{duration}" status="run"/>
@@ -200,7 +208,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>" time="{duration}" status="run">
@@ -209,7 +217,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>" time="{duration}" status="run">
@@ -218,7 +226,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>" time="{duration}" status="run">
@@ -227,7 +235,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture_2" name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>" time="{duration}" status="run"/>
@@ -240,7 +248,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture" name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - float" time="{duration}" status="run">
@@ -249,7 +257,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0f == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture" name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - int" time="{duration}" status="run">
@@ -258,7 +266,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Template_Fixture" name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double" time="{duration}" status="run"/>
@@ -270,7 +278,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
1 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Nttp_Fixture" name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3" time="{duration}" status="run">
@@ -279,7 +287,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
3 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Nttp_Fixture" name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6" time="{duration}" status="run">
@@ -288,7 +296,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
6 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Nttp_Fixture" name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1" time="{duration}" status="run"/>
@@ -300,7 +308,7 @@ FAILED:
REQUIRE( m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.Fixture" name="A TEST_CASE_METHOD based test run that succeeds" time="{duration}" status="run"/>
@@ -317,7 +325,7 @@ Class.tests.cpp:<line number>
<failure type="FAIL">
FAILED:
to infinity and beyond
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="A couple of nested sections followed by a failure/Outer/Inner" time="{duration}" status="run"/>
@@ -327,14 +335,14 @@ FAILED:
CHECK( &o1 == &o2 )
with expansion:
0x<hex digits> == 0x<hex digits>
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
<failure message="o1 == o2" type="CHECK">
FAILED:
CHECK( o1 == o2 )
with expansion:
{?} == {?}
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Absolute margin" time="{duration}" status="run"/>
@@ -344,7 +352,7 @@ Tricky.tests.cpp:<line number>
FAILED:
{Unknown expression after the reported line}
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Anonymous test case 1" time="{duration}" status="run"/>
@@ -414,14 +422,14 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" contains: "not there" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), ContainsSubstring( "STRING" )" type="CHECK_THAT">
FAILED:
CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )
with expansion:
"this string contains 'abc' as a substring" contains: "STRING"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Copy and then generate a range/from var and iterators" time="{duration}" status="run"/>
@@ -433,7 +441,7 @@ Matchers.tests.cpp:<line number>
FAILED:
REQUIRE_NOTHROW( throwCustom() )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Custom exceptions can be translated when testing for throwing as something else" time="{duration}" status="run">
@@ -441,27 +449,33 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE_THROWS_AS( throwCustom(), std::exception )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Custom std-exceptions can be custom translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
custom std exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Default scale is invisible to comparison" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Directly creating an EnumInfo" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Empty generators can SKIP in constructor" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+This generator is empty
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="Empty stream name opens cout stream" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Empty tag is not allowed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="EndsWith string matcher" time="{duration}" status="run">
<failure message="testStringForMatching(), EndsWith( "Substring" )" type="CHECK_THAT">
FAILED:
CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )
with expansion:
"this string contains 'abc' as a substring" ends with: "Substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No )" type="CHECK_THAT">
FAILED:
@@ -469,7 +483,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" ends with: "this" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Enums can quickly have stringification enabled using REGISTER_ENUM" time="{duration}" status="run"/>
@@ -482,91 +496,91 @@ FAILED:
CHECK( data.int_seven == 6 )
with expansion:
7 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven == 8" type="CHECK">
FAILED:
CHECK( data.int_seven == 8 )
with expansion:
7 == 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven == 0" type="CHECK">
FAILED:
CHECK( data.int_seven == 0 )
with expansion:
7 == 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 9.11f )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.11f ) )
with expansion:
9.1f == Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 9.0f )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.0f ) )
with expansion:
9.1f == Approx( 9.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 1 )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 1 ) )
with expansion:
9.1f == Approx( 1.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one == Approx( 0 )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one == Approx( 0 ) )
with expansion:
9.1f == Approx( 0.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.double_pi == Approx( 3.1415 )" type="CHECK">
FAILED:
CHECK( data.double_pi == Approx( 3.1415 ) )
with expansion:
3.1415926535 == Approx( 3.1415 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello == "goodbye"" type="CHECK">
FAILED:
CHECK( data.str_hello == "goodbye" )
with expansion:
"hello" == "goodbye"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello == "hell"" type="CHECK">
FAILED:
CHECK( data.str_hello == "hell" )
with expansion:
"hello" == "hell"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello == "hello1"" type="CHECK">
FAILED:
CHECK( data.str_hello == "hello1" )
with expansion:
"hello" == "hello1"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello.size() == 6" type="CHECK">
FAILED:
CHECK( data.str_hello.size() == 6 )
with expansion:
5 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="x == Approx( 1.301 )" type="CHECK">
FAILED:
CHECK( x == Approx( 1.301 ) )
with expansion:
1.3 == Approx( 1.301 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Equality checks that should succeed" time="{duration}" status="run"/>
@@ -578,7 +592,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" equals: "this string contains
'ABC' as a substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No )" type="CHECK_THAT">
FAILED:
@@ -586,7 +600,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" equals: "something else" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified" time="{duration}" status="run"/>
@@ -594,12 +608,12 @@ Matchers.tests.cpp:<line number>
<failure message="doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }" type="CHECK_THROWS_MATCHES">
FAILED:
CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }" type="REQUIRE_THROWS_MATCHES">
FAILED:
REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Exception matchers that fail/Type mismatch" time="{duration}" status="run">
@@ -607,13 +621,13 @@ Matchers.tests.cpp:<line number>
FAILED:
CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
<error message="throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }" type="REQUIRE_THROWS_MATCHES">
FAILED:
REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Exception matchers that fail/Contents are wrong" time="{duration}" status="run">
@@ -622,17 +636,18 @@ FAILED:
CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 }" type="REQUIRE_THROWS_MATCHES">
FAILED:
REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Exception matchers that succeed" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Exception message can be matched" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Exception messages can be tested for/exact match" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Exception messages can be tested for/different case" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Exception messages can be tested for/wildcarded" time="{duration}" status="run"/>
@@ -642,53 +657,56 @@ Matchers.tests.cpp:<line number>
FAILED:
CHECK_THROWS_AS( thisThrows(), std::string )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
<failure message="thisDoesntThrow(), std::domain_error" type="CHECK_THROWS_AS">
FAILED:
CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
<error message="thisThrows()" type="CHECK_NOTHROW">
FAILED:
CHECK_NOTHROW( thisThrows() )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="FAIL aborts the test" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="FAIL does not require an argument" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="FAIL_CHECK does not abort the test" time="{duration}" status="run">
<failure type="FAIL_CHECK">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Factorials are computed" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Filter generator throws exception for empty generator" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Relative/Some subnormal values" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Margin" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/ULPs" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Composed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: double/Constructor validation" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Floating point matchers: double/IsNaN" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Relative/Some subnormal values" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Margin" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/ULPs" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Composed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Floating point matchers: float/Constructor validation" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Floating point matchers: float/IsNaN" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Basic usage" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Generators -- adapters/Filtering by predicate/Throws if there are no matching values" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Generators -- adapters/Shortening a range" time="{duration}" status="run"/>
@@ -742,7 +760,7 @@ with expansion:
2 == 1
this message should be logged
so should this
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="INFO gets logged on failure, even if captured before successful assertions" time="{duration}" status="run">
@@ -753,7 +771,7 @@ with expansion:
2 == 1
this message may be logged later
this message should be logged
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="a == 0" type="CHECK">
FAILED:
@@ -763,7 +781,7 @@ with expansion:
this message may be logged later
this message should be logged
and this, but later
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="INFO is reset for each loop" time="{duration}" status="run">
@@ -774,7 +792,7 @@ with expansion:
10 < 10
current counter 10
i := 10
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Inequality checks that should fail" time="{duration}" status="run">
@@ -784,35 +802,35 @@ FAILED:
CHECK( data.int_seven != 7 )
with expansion:
7 != 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one != Approx( 9.1f )" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one != Approx( 9.1f ) )
with expansion:
9.1f != Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.double_pi != Approx( 3.1415926535 )" type="CHECK">
FAILED:
CHECK( data.double_pi != Approx( 3.1415926535 ) )
with expansion:
3.1415926535 != Approx( 3.1415926535 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello != "hello"" type="CHECK">
FAILED:
CHECK( data.str_hello != "hello" )
with expansion:
"hello" != "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello.size() != 5" type="CHECK">
FAILED:
CHECK( data.str_hello.size() != 5 )
with expansion:
5 != 5
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Inequality checks that should succeed" time="{duration}" status="run"/>
@@ -829,7 +847,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" ( ( contains: "string" or
contains: "different" ) and contains: "random" )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Matchers can be negated (Not) with the ! operator" time="{duration}" status="run"/>
@@ -839,35 +857,35 @@ FAILED:
CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )
with expansion:
"this string contains 'abc' as a substring" not contains: "substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/A" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/A" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/1/B" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mayfail test case with nested sections/2/B" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Mismatching exception messages failing the test" time="{duration}" status="run">
@@ -876,7 +894,7 @@ FAILED:
REQUIRE_THROWS_WITH( thisThrows(), "should fail" )
with expansion:
"expected exception" equals: "should fail"
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Multireporter calls reporters and listeners in correct order" time="{duration}" status="run"/>
@@ -889,7 +907,7 @@ Exception.tests.cpp:<line number>
<error type="TEST_CASE">
FAILED:
custom exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Objects that evaluated in boolean contexts can be checked" time="{duration}" status="run"/>
@@ -900,133 +918,133 @@ FAILED:
CHECK( data.int_seven > 7 )
with expansion:
7 > 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < 7" type="CHECK">
FAILED:
CHECK( data.int_seven < 7 )
with expansion:
7 < 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven > 8" type="CHECK">
FAILED:
CHECK( data.int_seven > 8 )
with expansion:
7 > 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < 6" type="CHECK">
FAILED:
CHECK( data.int_seven < 6 )
with expansion:
7 < 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < 0" type="CHECK">
FAILED:
CHECK( data.int_seven < 0 )
with expansion:
7 < 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven < -1" type="CHECK">
FAILED:
CHECK( data.int_seven < -1 )
with expansion:
7 < -1
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven >= 8" type="CHECK">
FAILED:
CHECK( data.int_seven >= 8 )
with expansion:
7 >= 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.int_seven <= 6" type="CHECK">
FAILED:
CHECK( data.int_seven <= 6 )
with expansion:
7 <= 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one < 9" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one < 9 )
with expansion:
9.1f < 9
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one > 10" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one > 10 )
with expansion:
9.1f > 10
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.float_nine_point_one > 9.2" type="CHECK">
FAILED:
CHECK( data.float_nine_point_one > 9.2 )
with expansion:
9.1f > 9.2
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello > "hello"" type="CHECK">
FAILED:
CHECK( data.str_hello > "hello" )
with expansion:
"hello" > "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello < "hello"" type="CHECK">
FAILED:
CHECK( data.str_hello < "hello" )
with expansion:
"hello" < "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello > "hellp"" type="CHECK">
FAILED:
CHECK( data.str_hello > "hellp" )
with expansion:
"hello" > "hellp"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello > "z"" type="CHECK">
FAILED:
CHECK( data.str_hello > "z" )
with expansion:
"hello" > "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello < "hellm"" type="CHECK">
FAILED:
CHECK( data.str_hello < "hellm" )
with expansion:
"hello" < "hellm"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello < "a"" type="CHECK">
FAILED:
CHECK( data.str_hello < "a" )
with expansion:
"hello" < "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello >= "z"" type="CHECK">
FAILED:
CHECK( data.str_hello >= "z" )
with expansion:
"hello" >= "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="data.str_hello <= "a"" type="CHECK">
FAILED:
CHECK( data.str_hello <= "a" )
with expansion:
"hello" <= "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Ordering comparison checks that should succeed" time="{duration}" status="run"/>
@@ -1036,52 +1054,19 @@ Condition.tests.cpp:<line number>
<failure type="FAIL">
FAILED:
Message from section one
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Output from all sections is reported/two" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
Message from section two
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Overloaded comma or address-of operators are not used" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Empty test spec should have no filters" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from empty string should have no filters" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from just a comma should have no filters" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from name should have one filter" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from quoted name should have one filter" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Test spec from name should have one filter" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at the start" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at the end" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at both ends" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Redundant wildcard at the start" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Redundant wildcard at the end" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Redundant wildcard at both ends" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcard at both ends, redundant at start" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Just wildcard" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Single tag" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Single tag, two matches" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Two tags" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Two tags, spare separated" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Wildcarded name and tag" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Single tag exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/One tag exclusion and one tag inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/One tag exclusion and one wldcarded name inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/One tag exclusion, using exclude:, and one wldcarded name inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/name exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/wildcarded name exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/wildcarded name exclusion with tag inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/wildcarded name exclusion, using exclude:, with tag inclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/two wildcarded names" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/empty tag" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/empty quoted name" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/quoted string followed by tag exclusion" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Leading and trailing spaces in test spec" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Leading and trailing spaces in test name" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Shortened hide tags are split apart when parsing" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Parse test names and tags/Shortened hide tags also properly handle exclusion" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Parse uints/proper inputs" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Parse uints/Bad inputs" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Parsed tags are matched case insensitive" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/shard-count" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Parsing sharding-related cli flags/Negative shard count reports error" time="{duration}" status="run"/>
@@ -1145,7 +1130,7 @@ FAILED:
CHECK( truthy(false) )
with expansion:
Hey, its truthy!
-Decomposition.tests.cpp:<line number>
+at Decomposition.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Regex string matcher" time="{duration}" status="run">
@@ -1155,7 +1140,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" matches "this STRING contains
'abc' as a substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), Matches( "contains 'abc' as a substring" )" type="CHECK_THAT">
FAILED:
@@ -1163,7 +1148,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" matches "contains 'abc' as a
substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), Matches( "this string contains 'abc' as a" )" type="CHECK_THAT">
FAILED:
@@ -1171,7 +1156,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" matches "this string contains
'abc' as a" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Registering reporter with '::' in name fails" time="{duration}" status="run"/>
@@ -1235,7 +1220,7 @@ FAILED:
CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
with expansion:
"this string contains 'abc' as a substring" starts with: "This String"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No )" type="CHECK_THAT">
FAILED:
@@ -1243,7 +1228,7 @@ FAILED:
with expansion:
"this string contains 'abc' as a substring" starts with: "string" (case
insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Static arrays are convertible to string/Single item" time="{duration}" status="run"/>
@@ -1291,7 +1276,7 @@ with expansion:
$a = 20;
}
"
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" time="{duration}" status="run"/>
@@ -1364,14 +1349,14 @@ Misc.tests.cpp:<line number>
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Testing checked-if 3" time="{duration}" status="run">
<skipped message="TEST_CASE tagged with !mayfail"/>
<failure type="FAIL">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="The NO_FAIL macro reports a failure but does not fail the test" time="{duration}" status="run"/>
@@ -1384,7 +1369,7 @@ Misc.tests.cpp:<line number>
<error type="TEST_CASE">
FAILED:
For some reason someone is throwing a string literal!
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Tracker" time="{duration}" status="run"/>
@@ -1398,11 +1383,19 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Tracker/successfully close one section, then find another/Re-enter - skips S1 and enters S2/fail S2" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Tracker/open a nested section" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Trim strings" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Unexpected exceptions can be translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
3.14
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="Upcasting special member functions/Move constructor" time="{duration}" status="run"/>
@@ -1413,10 +1406,10 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
@@ -1426,10 +1419,10 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
@@ -1439,13 +1432,33 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" time="{duration}" status="run"/>
- <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>
@@ -1461,7 +1474,7 @@ FAILED:
CHECK_THAT( empty, Approx( t1 ) )
with expansion:
{ } is approx: { 1.0, 2.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector Approx matcher -- failing/Just different vectors" time="{duration}" status="run">
@@ -1470,7 +1483,7 @@ FAILED:
CHECK_THAT( v1, Approx( v2 ) )
with expansion:
{ 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers/Contains (element)" time="{duration}" status="run"/>
@@ -1484,14 +1497,14 @@ FAILED:
CHECK_THAT( v, VectorContains( -1 ) )
with expansion:
{ 1, 2, 3 } Contains: -1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="empty, VectorContains( 1 )" type="CHECK_THAT">
FAILED:
CHECK_THAT( empty, VectorContains( 1 ) )
with expansion:
{ } Contains: 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers that fail/Contains (vector)" time="{duration}" status="run">
@@ -1500,14 +1513,14 @@ FAILED:
CHECK_THAT( empty, Contains( v ) )
with expansion:
{ } Contains: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="v, Contains( v2 )" type="CHECK_THAT">
FAILED:
CHECK_THAT( v, Contains( v2 ) )
with expansion:
{ 1, 2, 3 } Contains: { 1, 2, 4 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers that fail/Equals" time="{duration}" status="run">
@@ -1516,28 +1529,28 @@ FAILED:
CHECK_THAT( v, Equals( v2 ) )
with expansion:
{ 1, 2, 3 } Equals: { 1, 2 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="v2, Equals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( v2, Equals( v ) )
with expansion:
{ 1, 2 } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="empty, Equals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( empty, Equals( v ) )
with expansion:
{ } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="v, Equals( empty )" type="CHECK_THAT">
FAILED:
CHECK_THAT( v, Equals( empty ) )
with expansion:
{ 1, 2, 3 } Equals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="Vector matchers that fail/UnorderedEquals" time="{duration}" status="run">
@@ -1546,28 +1559,28 @@ FAILED:
CHECK_THAT( v, UnorderedEquals( empty ) )
with expansion:
{ 1, 2, 3 } UnorderedEquals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="empty, UnorderedEquals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( empty, UnorderedEquals( v ) )
with expansion:
{ } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="permuted, UnorderedEquals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 1, 3 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="permuted, UnorderedEquals( v )" type="CHECK_THAT">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 3, 1 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="When checked exceptions are thrown they can be expected or unexpected" time="{duration}" status="run"/>
@@ -1575,7 +1588,7 @@ Matchers.tests.cpp:<line number>
<error type="TEST_CASE">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown during a CHECK the test should continue" time="{duration}" status="run">
@@ -1583,7 +1596,7 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown during a REQUIRE the test should abort fail" time="{duration}" status="run">
@@ -1591,7 +1604,7 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown from functions they are always failures" time="{duration}" status="run">
@@ -1599,14 +1612,14 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="When unchecked exceptions are thrown from sections they are always failures/section name" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="X/level/0/a" time="{duration}" status="run"/>
@@ -1622,6 +1635,12 @@ Exception.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="XmlEncode/string with control char (1)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="XmlEncode/string with control char (x7F)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="XmlWriter writes boolean attributes as true/false" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="a succeeding test can still be skipped" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="analyse no analysis" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="array<int, N> -> toString" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="benchmark function call/without chronometer" time="{duration}" status="run"/>
@@ -1634,7 +1653,7 @@ FAILED:
REQUIRE( testCheckedElse( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="checkedIf" time="{duration}" status="run"/>
@@ -1644,7 +1663,7 @@ FAILED:
REQUIRE( testCheckedIf( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="classify_outliers/none" time="{duration}" status="run"/>
@@ -1656,25 +1675,80 @@ Misc.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="comparisons between const int variables" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="comparisons between int variables" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="convertToBits" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="dynamic skipping works with generators" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+skipping because answer = 41
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped type="SKIP">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="empty tags are not allowed" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="erfc_inv" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="estimate_clock_resolution" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/d (leaf)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="even more nested SECTION tests/c/e (leaf)" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="even more nested SECTION tests/f (leaf)" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="failed assertions before SKIP cause test case to fail" time="{duration}" status="run">
+ <skipped message="TEST_CASE tagged with !mayfail"/>
+ <failure message="3 == 4" type="CHECK">
+FAILED:
+ CHECK( 3 == 4 )
+at Skip.tests.cpp:<line number>
+ </failure>
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="failing for some generator values causes entire test case to fail" time="{duration}" status="run">
+ <failure type="FAIL">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </failure>
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <failure type="FAIL">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </failure>
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="failing in some unskipped sections causes entire test case to fail/skipped" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="failing in some unskipped sections causes entire test case to fail/not skipped" time="{duration}" status="run">
+ <skipped message="TEST_CASE tagged with !mayfail"/>
+ <failure type="FAIL">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </failure>
+ </testcase>
<testcase classname="<exe-name>.global" name="is_unary_function" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="just failure" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
Previous info should not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="just failure after unscoped info" time="{duration}" status="run">
<failure type="FAIL">
FAILED:
previous unscoped info SHOULD not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="long long" time="{duration}" status="run"/>
@@ -1684,7 +1758,7 @@ FAILED:
CHECK( b > a )
with expansion:
0 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="looped SECTION tests/b is currently: 1" time="{duration}" status="run">
@@ -1693,7 +1767,7 @@ FAILED:
CHECK( b > a )
with expansion:
1 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="looped SECTION tests/b is currently: 2" time="{duration}" status="run"/>
@@ -1711,7 +1785,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[0] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1719,7 +1793,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[1] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1727,7 +1801,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[3] (3) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1735,7 +1809,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[4] (5) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1743,7 +1817,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[6] (13) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="( fib[i] % 2 ) == 0" type="CHECK">
FAILED:
@@ -1751,7 +1825,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[7] (21) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="makeStream recognizes %debug stream name" time="{duration}" status="run"/>
@@ -1767,13 +1841,26 @@ FAILED:
REQUIRE( a == b )
with expansion:
1 == 2
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="more nested SECTION tests/doesn't equal/less than" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="nested SECTION tests/doesn't equal/not equal" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B2/B" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="nested sections can be skipped dynamically at runtime/B" time="{duration}" status="run">
+ <system-out>
+a!
+b1!
+!
+ </system-out>
+ </testcase>
<testcase classname="<exe-name>.global" name="non streamable - with conv. op" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="non-copyable objects" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="normal_cdf" time="{duration}" status="run"/>
@@ -1784,7 +1871,7 @@ Misc.tests.cpp:<line number>
FAILED:
REQUIRE( false )
this SHOULD be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="null strings" time="{duration}" status="run"/>
@@ -1801,7 +1888,7 @@ FAILED:
REQUIRE( false )
this SHOULD be seen
this SHOULD also be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="prints unscoped info only for the first assertion" time="{duration}" status="run">
@@ -1809,7 +1896,7 @@ Message.tests.cpp:<line number>
FAILED:
CHECK( false )
this SHOULD be seen only ONCE
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="random SECTION tests/doesn't equal" time="{duration}" status="run"/>
@@ -1825,12 +1912,20 @@ Message.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="resolution" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="run_for_at_least, chronometer" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="run_for_at_least, int" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/not skipped" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/skipped" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
+ <testcase classname="<exe-name>.global" name="sections can be skipped dynamically at runtime/also not skipped" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="send a single char to INFO" time="{duration}" status="run">
<failure message="false" type="REQUIRE">
FAILED:
REQUIRE( false )
3
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="sends information to INFO" time="{duration}" status="run">
@@ -1839,10 +1934,17 @@ FAILED:
REQUIRE( false )
hi
i := 7
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="shortened hide tags are split apart" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="skipped tests can optionally provide a reason" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="splitString" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="stacks unscoped info in loops" time="{duration}" status="run">
<failure message="false" type="CHECK">
@@ -1852,7 +1954,7 @@ Count 1 to 3...
1
2
3
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="false" type="CHECK">
FAILED:
@@ -1861,7 +1963,7 @@ Count 4 to 6...
4
5
6
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testcase>
<testcase classname="<exe-name>.global" name="startsWith" time="{duration}" status="run"/>
@@ -1887,11 +1989,17 @@ Message.tests.cpp:<line number>
<testcase classname="<exe-name>.global" name="strlen3" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="tables" time="{duration}" status="run"/>
<testcase classname="<exe-name>.global" name="tags with dots in later positions are not parsed as hidden" time="{duration}" status="run"/>
+ <testcase classname="<exe-name>.global" name="tests can be skipped dynamically at runtime" time="{duration}" status="run">
+ <skipped type="SKIP">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testcase>
<testcase classname="<exe-name>.global" name="thrown std::strings are translated" time="{duration}" status="run">
<error type="TEST_CASE">
FAILED:
Why would you throw a std::string?
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testcase>
<testcase classname="<exe-name>.global" name="toString on const wchar_t const pointer returns the string contents" time="{duration}" status="run"/>
@@ -1936,6 +2044,9 @@ This would not be caught previously
A string sent directly to stdout
Message from section one
Message from section two
+a!
+b1!
+!
</system-out>
<system-err>
Nor would this
diff --git a/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
index a9319a62800b1b8db2548b700c25d6ff75422164..592887f9c43fa5ccfcd1f8234c06cb639a640112 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
-<!-- rng-seed=1 -->
+<!-- filters='"*" ~[!nonportable] ~[!benchmark] ~[approvals]' rng-seed=1 -->
<testExecutions version="1"loose text artifact
>
<file path="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp">
@@ -9,44 +9,6 @@
<testCase name="is_unary_function" duration="{duration}"/>
</file>
<file path="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp">
- <testCase name="#1905 -- test spec parser properly clears internal state between compound tests" duration="{duration}"/>
- <testCase name="#1912 -- test spec parser handles escaping/Various parentheses" duration="{duration}"/>
- <testCase name="#1912 -- test spec parser handles escaping/backslash in test name" duration="{duration}"/>
- <testCase name="Parse test names and tags/Empty test spec should have no filters" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from empty string should have no filters" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from just a comma should have no filters" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from name should have one filter" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from quoted name should have one filter" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from name should have one filter" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at the start" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at the end" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at both ends" duration="{duration}"/>
- <testCase name="Parse test names and tags/Redundant wildcard at the start" duration="{duration}"/>
- <testCase name="Parse test names and tags/Redundant wildcard at the end" duration="{duration}"/>
- <testCase name="Parse test names and tags/Redundant wildcard at both ends" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at both ends, redundant at start" duration="{duration}"/>
- <testCase name="Parse test names and tags/Just wildcard" duration="{duration}"/>
- <testCase name="Parse test names and tags/Single tag" duration="{duration}"/>
- <testCase name="Parse test names and tags/Single tag, two matches" duration="{duration}"/>
- <testCase name="Parse test names and tags/Two tags" duration="{duration}"/>
- <testCase name="Parse test names and tags/Two tags, spare separated" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcarded name and tag" duration="{duration}"/>
- <testCase name="Parse test names and tags/Single tag exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/One tag exclusion and one tag inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/One tag exclusion and one wldcarded name inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/One tag exclusion, using exclude:, and one wldcarded name inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/name exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/wildcarded name exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/wildcarded name exclusion with tag inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/wildcarded name exclusion, using exclude:, with tag inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/two wildcarded names" duration="{duration}"/>
- <testCase name="Parse test names and tags/empty tag" duration="{duration}"/>
- <testCase name="Parse test names and tags/empty quoted name" duration="{duration}"/>
- <testCase name="Parse test names and tags/quoted string followed by tag exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/Leading and trailing spaces in test spec" duration="{duration}"/>
- <testCase name="Parse test names and tags/Leading and trailing spaces in test name" duration="{duration}"/>
- <testCase name="Parse test names and tags/Shortened hide tags are split apart when parsing" duration="{duration}"/>
- <testCase name="Parse test names and tags/Shortened hide tags also properly handle exclusion" duration="{duration}"/>
<testCase name="Parsing sharding-related cli flags/shard-count" duration="{duration}"/>
<testCase name="Parsing sharding-related cli flags/Negative shard count reports error" duration="{duration}"/>
<testCase name="Parsing sharding-related cli flags/Zero shard count reports error" duration="{duration}"/>
@@ -109,6 +71,7 @@
<testCase name="convertToBits" duration="{duration}"/>
</file>
<file path="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp">
+ <testCase name="Filter generator throws exception for empty generator" duration="{duration}"/>
<testCase name="Generators internals/Single value" duration="{duration}"/>
<testCase name="Generators internals/Preset values" duration="{duration}"/>
<testCase name="Generators internals/Generator combinator" duration="{duration}"/>
@@ -157,6 +120,10 @@
<testCase name="warmup" duration="{duration}"/>
<testCase name="weighted_average_quantile" duration="{duration}"/>
</file>
+ <file path="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp">
+ <testCase name="Parse uints/proper inputs" duration="{duration}"/>
+ <testCase name="Parse uints/Bad inputs" duration="{duration}"/>
+ </file>
<file path="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp">
<testCase name="#1938 - GENERATE after a section/A" duration="{duration}"/>
<testCase name="#1938 - GENERATE after a section/B" duration="{duration}"/>
@@ -266,7 +233,6 @@
<testCase name="startsWith" duration="{duration}"/>
</file>
<file path="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp">
- <testCase name="Empty tag is not allowed" duration="{duration}"/>
<testCase name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" duration="{duration}"/>
<testCase name="Tag alias can be registered against tag patterns/Tag aliases must be of the form [@name]" duration="{duration}"/>
<testCase name="Tags with spaces and non-alphanumerical characters are accepted" duration="{duration}"/>
@@ -283,6 +249,11 @@
<testCase name="Hashing different test cases produces different result/Different tags" duration="{duration}"/>
<testCase name="Hashing test case produces same hash across multiple calls" duration="{duration}"/>
</file>
+ <file path="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp">
+ <testCase name="#1905 -- test spec parser properly clears internal state between compound tests" duration="{duration}"/>
+ <testCase name="#1912 -- test spec parser handles escaping/Various parentheses" duration="{duration}"/>
+ <testCase name="#1912 -- test spec parser handles escaping/backslash in test name" duration="{duration}"/>
+ </file>
<file path="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp">
<testCase name="Parsed tags are matched case insensitive" duration="{duration}"/>
<testCase name="Parsing tags with non-alphabetical characters is pass-through" duration="{duration}"/>
@@ -359,7 +330,7 @@ FAILED:
REQUIRE( s == "world" )
with expansion:
"hello" == "world"
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A METHOD_AS_TEST_CASE based test run that succeeds" duration="{duration}"/>
@@ -369,7 +340,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>" duration="{duration}">
@@ -378,7 +349,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>" duration="{duration}">
@@ -387,7 +358,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>" duration="{duration}">
@@ -396,7 +367,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>" duration="{duration}"/>
@@ -409,7 +380,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>" duration="{duration}">
@@ -418,7 +389,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>" duration="{duration}">
@@ -427,7 +398,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>" duration="{duration}">
@@ -436,7 +407,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>" duration="{duration}"/>
@@ -449,7 +420,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - float" duration="{duration}">
@@ -458,7 +429,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0f == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - int" duration="{duration}">
@@ -467,7 +438,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double" duration="{duration}"/>
@@ -479,7 +450,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
1 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3" duration="{duration}">
@@ -488,7 +459,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
3 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6" duration="{duration}">
@@ -497,7 +468,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
6 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1" duration="{duration}"/>
@@ -509,7 +480,7 @@ FAILED:
REQUIRE( m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEST_CASE_METHOD based test run that succeeds" duration="{duration}"/>
@@ -537,52 +508,52 @@ Class.tests.cpp:<line number>
<failure message="CHECK(false != false)">
FAILED:
CHECK( false != false )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(true != true)">
FAILED:
CHECK( true != true )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(!true)">
FAILED:
CHECK( !true )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK_FALSE(!(true))">
FAILED:
CHECK_FALSE( true )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(!trueValue)">
FAILED:
CHECK( !trueValue )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK_FALSE(!(trueValue))">
FAILED:
CHECK_FALSE( trueValue )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(!(1 == 1))">
FAILED:
CHECK( !(1 == 1) )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK_FALSE(!(1 == 1))">
FAILED:
CHECK_FALSE( 1 == 1 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="'Not' checks that should succeed" duration="{duration}"/>
@@ -595,91 +566,91 @@ FAILED:
CHECK( data.int_seven == 6 )
with expansion:
7 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.int_seven == 8)">
FAILED:
CHECK( data.int_seven == 8 )
with expansion:
7 == 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.int_seven == 0)">
FAILED:
CHECK( data.int_seven == 0 )
with expansion:
7 == 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 9.11f ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.11f ) )
with expansion:
9.1f == Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 9.0f ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.0f ) )
with expansion:
9.1f == Approx( 9.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 1 ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 1 ) )
with expansion:
9.1f == Approx( 1.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 0 ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 0 ) )
with expansion:
9.1f == Approx( 0.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.double_pi == Approx( 3.1415 ))">
FAILED:
CHECK( data.double_pi == Approx( 3.1415 ) )
with expansion:
3.1415926535 == Approx( 3.1415 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello == "goodbye")">
FAILED:
CHECK( data.str_hello == "goodbye" )
with expansion:
"hello" == "goodbye"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello == "hell")">
FAILED:
CHECK( data.str_hello == "hell" )
with expansion:
"hello" == "hell"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello == "hello1")">
FAILED:
CHECK( data.str_hello == "hello1" )
with expansion:
"hello" == "hello1"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello.size() == 6)">
FAILED:
CHECK( data.str_hello.size() == 6 )
with expansion:
5 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(x == Approx( 1.301 ))">
FAILED:
CHECK( x == Approx( 1.301 ) )
with expansion:
1.3 == Approx( 1.301 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Equality checks that should succeed" duration="{duration}"/>
@@ -689,60 +660,60 @@ FAILED:
CHECK( data.int_seven != 7 )
with expansion:
7 != 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one != Approx( 9.1f ))">
FAILED:
CHECK( data.float_nine_point_one != Approx( 9.1f ) )
with expansion:
9.1f != Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.double_pi != Approx( 3.1415926535 ))">
FAILED:
CHECK( data.double_pi != Approx( 3.1415926535 ) )
with expansion:
3.1415926535 != Approx( 3.1415926535 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello != "hello")">
FAILED:
CHECK( data.str_hello != "hello" )
with expansion:
"hello" != "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello.size() != 5)">
FAILED:
CHECK( data.str_hello.size() != 5 )
with expansion:
5 != 5
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Inequality checks that should succeed" duration="{duration}"/>
<testCase name="Mayfail test case with nested sections/1/A" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Mayfail test case with nested sections/2/A" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Mayfail test case with nested sections/1/B" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Mayfail test case with nested sections/2/B" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Ordering comparison checks that should fail" duration="{duration}">
@@ -751,133 +722,133 @@ FAILED:
CHECK( data.int_seven > 7 )
with expansion:
7 > 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < 7)">
FAILED:
CHECK( data.int_seven < 7 )
with expansion:
7 < 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven > 8)">
FAILED:
CHECK( data.int_seven > 8 )
with expansion:
7 > 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < 6)">
FAILED:
CHECK( data.int_seven < 6 )
with expansion:
7 < 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < 0)">
FAILED:
CHECK( data.int_seven < 0 )
with expansion:
7 < 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < -1)">
FAILED:
CHECK( data.int_seven < -1 )
with expansion:
7 < -1
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven >= 8)">
FAILED:
CHECK( data.int_seven >= 8 )
with expansion:
7 >= 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven <= 6)">
FAILED:
CHECK( data.int_seven <= 6 )
with expansion:
7 <= 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.float_nine_point_one < 9)">
FAILED:
CHECK( data.float_nine_point_one < 9 )
with expansion:
9.1f < 9
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.float_nine_point_one > 10)">
FAILED:
CHECK( data.float_nine_point_one > 10 )
with expansion:
9.1f > 10
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.float_nine_point_one > 9.2)">
FAILED:
CHECK( data.float_nine_point_one > 9.2 )
with expansion:
9.1f > 9.2
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello > "hello")">
FAILED:
CHECK( data.str_hello > "hello" )
with expansion:
"hello" > "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello < "hello")">
FAILED:
CHECK( data.str_hello < "hello" )
with expansion:
"hello" < "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello > "hellp")">
FAILED:
CHECK( data.str_hello > "hellp" )
with expansion:
"hello" > "hellp"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello > "z")">
FAILED:
CHECK( data.str_hello > "z" )
with expansion:
"hello" > "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello < "hellm")">
FAILED:
CHECK( data.str_hello < "hellm" )
with expansion:
"hello" < "hellm"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello < "a")">
FAILED:
CHECK( data.str_hello < "a" )
with expansion:
"hello" < "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello >= "z")">
FAILED:
CHECK( data.str_hello >= "z" )
with expansion:
"hello" >= "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello <= "a")">
FAILED:
CHECK( data.str_hello <= "a" )
with expansion:
"hello" <= "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Ordering comparison checks that should succeed" duration="{duration}"/>
@@ -892,7 +863,7 @@ FAILED:
CHECK( truthy(false) )
with expansion:
Hey, its truthy!
-Decomposition.tests.cpp:<line number>
+at Decomposition.tests.cpp:<line number>
</failure>
</testCase>
</file>
@@ -910,7 +881,7 @@ Decomposition.tests.cpp:<line number>
FAILED:
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="#748 - captures with unexpected exceptions/inside REQUIRE_NOTHROW" duration="{duration}">
@@ -919,7 +890,7 @@ FAILED:
REQUIRE_NOTHROW( thisThrows() )
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="#748 - captures with unexpected exceptions/inside REQUIRE_THROWS" duration="{duration}"/>
@@ -928,7 +899,7 @@ Exception.tests.cpp:<line number>
FAILED:
{Unknown expression after the reported line}
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Custom exceptions can be translated when testing for nothrow" duration="{duration}">
@@ -936,7 +907,7 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE_NOTHROW( throwCustom() )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Custom exceptions can be translated when testing for throwing as something else" duration="{duration}">
@@ -944,14 +915,14 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE_THROWS_AS( throwCustom(), std::exception )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Custom std-exceptions can be custom translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
custom std exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Exception messages can be tested for/exact match" duration="{duration}"/>
@@ -962,18 +933,18 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK_THROWS_AS( thisThrows(), std::string )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
<failure message="CHECK_THROWS_AS(thisDoesntThrow(), std::domain_error)">
FAILED:
CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
<error message="CHECK_NOTHROW(thisThrows())">
FAILED:
CHECK_NOTHROW( thisThrows() )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Mismatching exception messages failing the test" duration="{duration}">
@@ -982,28 +953,28 @@ FAILED:
REQUIRE_THROWS_WITH( thisThrows(), "should fail" )
with expansion:
"expected exception" equals: "should fail"
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Non-std exceptions can be translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
custom exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Thrown string literals are translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
For some reason someone is throwing a string literal!
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Unexpected exceptions can be translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
3.14
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When checked exceptions are thrown they can be expected or unexpected" duration="{duration}"/>
@@ -1011,7 +982,7 @@ Exception.tests.cpp:<line number>
<error message="TEST_CASE()">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown during a CHECK the test should continue" duration="{duration}">
@@ -1019,7 +990,7 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown during a REQUIRE the test should abort fail" duration="{duration}">
@@ -1027,7 +998,7 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown from functions they are always failures" duration="{duration}">
@@ -1035,27 +1006,34 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown from sections they are always failures/section name" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="thrown std::strings are translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
Why would you throw a std::string?
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
</file>
<file path="tests/<exe-name>/UsageTests/Generators.tests.cpp">
<testCase name="#1913 - GENERATE inside a for loop should not keep recreating the generator" duration="{duration}"/>
<testCase name="#1913 - GENERATEs can share a line" duration="{duration}"/>
+ <testCase name="#2615 - Throwing in constructor generator fails test case but does not abort" duration="{duration}">
+ <skipped message="TEST_CASE()">
+FAILED:
+failure to init
+at Generators.tests.cpp:<line number>
+ </skipped>
+ </testCase>
<testCase name="3x3x3 ints" duration="{duration}"/>
<testCase name="Copy and then generate a range/from var and iterators" duration="{duration}"/>
<testCase name="Copy and then generate a range/From a temporary container" duration="{duration}"/>
@@ -1099,14 +1077,14 @@ FAILED:
CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" contains: "not there" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), ContainsSubstring( "STRING" ))">
FAILED:
CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )
with expansion:
"this string contains 'abc' as a substring" contains: "STRING"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="EndsWith string matcher" duration="{duration}">
@@ -1115,14 +1093,14 @@ FAILED:
CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )
with expansion:
"this string contains 'abc' as a substring" ends with: "Substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ))">
FAILED:
CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" ends with: "this" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Equals" duration="{duration}"/>
@@ -1132,26 +1110,26 @@ FAILED:
CHECK_THAT( testStringForMatching(), Equals( "this string contains 'ABC' as a substring" ) )
with expansion:
"this string contains 'abc' as a substring" equals: "this string contains 'ABC' as a substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ))">
FAILED:
CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" equals: "something else" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Exception matchers that fail/No exception" duration="{duration}">
<failure message="CHECK_THROWS_MATCHES(doesNotThrow(), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="REQUIRE_THROWS_MATCHES(doesNotThrow(), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Exception matchers that fail/Type mismatch" duration="{duration}">
@@ -1159,13 +1137,13 @@ Matchers.tests.cpp:<line number>
FAILED:
CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
<error message="REQUIRE_THROWS_MATCHES(throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Exception matchers that fail/Contents are wrong" duration="{duration}">
@@ -1174,17 +1152,18 @@ FAILED:
CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="REQUIRE_THROWS_MATCHES(throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Exception matchers that succeed" duration="{duration}"/>
+ <testCase name="Exception message can be matched" duration="{duration}"/>
<testCase name="Exceptions matchers" duration="{duration}"/>
<testCase name="Floating point matchers: double/Relative" duration="{duration}"/>
<testCase name="Floating point matchers: double/Relative/Some subnormal values" duration="{duration}"/>
@@ -1192,12 +1171,14 @@ Matchers.tests.cpp:<line number>
<testCase name="Floating point matchers: double/ULPs" duration="{duration}"/>
<testCase name="Floating point matchers: double/Composed" duration="{duration}"/>
<testCase name="Floating point matchers: double/Constructor validation" duration="{duration}"/>
+ <testCase name="Floating point matchers: double/IsNaN" duration="{duration}"/>
<testCase name="Floating point matchers: float/Relative" duration="{duration}"/>
<testCase name="Floating point matchers: float/Relative/Some subnormal values" duration="{duration}"/>
<testCase name="Floating point matchers: float/Margin" duration="{duration}"/>
<testCase name="Floating point matchers: float/ULPs" duration="{duration}"/>
<testCase name="Floating point matchers: float/Composed" duration="{duration}"/>
<testCase name="Floating point matchers: float/Constructor validation" duration="{duration}"/>
+ <testCase name="Floating point matchers: float/IsNaN" duration="{duration}"/>
<testCase name="Matchers can be (AllOf) composed with the && operator" duration="{duration}"/>
<testCase name="Matchers can be (AnyOf) composed with the || operator" duration="{duration}"/>
<testCase name="Matchers can be composed with both && and ||" duration="{duration}"/>
@@ -1207,7 +1188,7 @@ FAILED:
CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) || ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )
with expansion:
"this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Matchers can be negated (Not) with the ! operator" duration="{duration}"/>
@@ -1217,7 +1198,7 @@ FAILED:
CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )
with expansion:
"this string contains 'abc' as a substring" not contains: "substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Overloaded comma or address-of operators are not used" duration="{duration}"/>
@@ -1228,21 +1209,21 @@ FAILED:
CHECK_THAT( testStringForMatching(), Matches( "this STRING contains 'abc' as a substring" ) )
with expansion:
"this string contains 'abc' as a substring" matches "this STRING contains 'abc' as a substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), Matches( "contains 'abc' as a substring" ))">
FAILED:
CHECK_THAT( testStringForMatching(), Matches( "contains 'abc' as a substring" ) )
with expansion:
"this string contains 'abc' as a substring" matches "contains 'abc' as a substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), Matches( "this string contains 'abc' as a" ))">
FAILED:
CHECK_THAT( testStringForMatching(), Matches( "this string contains 'abc' as a" ) )
with expansion:
"this string contains 'abc' as a substring" matches "this string contains 'abc' as a" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Regression test #1" duration="{duration}"/>
@@ -1252,14 +1233,14 @@ FAILED:
CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
with expansion:
"this string contains 'abc' as a substring" starts with: "This String"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ))">
FAILED:
CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" starts with: "string" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="String matchers" duration="{duration}"/>
@@ -1273,7 +1254,7 @@ FAILED:
CHECK_THAT( empty, Approx( t1 ) )
with expansion:
{ } is approx: { 1.0, 2.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector Approx matcher -- failing/Just different vectors" duration="{duration}">
@@ -1282,7 +1263,7 @@ FAILED:
CHECK_THAT( v1, Approx( v2 ) )
with expansion:
{ 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers/Contains (element)" duration="{duration}"/>
@@ -1296,14 +1277,14 @@ FAILED:
CHECK_THAT( v, VectorContains( -1 ) )
with expansion:
{ 1, 2, 3 } Contains: -1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(empty, VectorContains( 1 ))">
FAILED:
CHECK_THAT( empty, VectorContains( 1 ) )
with expansion:
{ } Contains: 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers that fail/Contains (vector)" duration="{duration}">
@@ -1312,14 +1293,14 @@ FAILED:
CHECK_THAT( empty, Contains( v ) )
with expansion:
{ } Contains: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(v, Contains( v2 ))">
FAILED:
CHECK_THAT( v, Contains( v2 ) )
with expansion:
{ 1, 2, 3 } Contains: { 1, 2, 4 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers that fail/Equals" duration="{duration}">
@@ -1328,28 +1309,28 @@ FAILED:
CHECK_THAT( v, Equals( v2 ) )
with expansion:
{ 1, 2, 3 } Equals: { 1, 2 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(v2, Equals( v ))">
FAILED:
CHECK_THAT( v2, Equals( v ) )
with expansion:
{ 1, 2 } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(empty, Equals( v ))">
FAILED:
CHECK_THAT( empty, Equals( v ) )
with expansion:
{ } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(v, Equals( empty ))">
FAILED:
CHECK_THAT( v, Equals( empty ) )
with expansion:
{ 1, 2, 3 } Equals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers that fail/UnorderedEquals" duration="{duration}">
@@ -1358,28 +1339,28 @@ FAILED:
CHECK_THAT( v, UnorderedEquals( empty ) )
with expansion:
{ 1, 2, 3 } UnorderedEquals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(empty, UnorderedEquals( v ))">
FAILED:
CHECK_THAT( empty, UnorderedEquals( v ) )
with expansion:
{ } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(permuted, UnorderedEquals( v ))">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 1, 3 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(permuted, UnorderedEquals( v ))">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 3, 1 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
</file>
@@ -1393,16 +1374,24 @@ Matchers.tests.cpp:<line number>
<testCase name="Basic use of the Empty range matcher/Simple, std-provided containers" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type with empty" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type requires ADL found empty free function" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Basic usage" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
- <testCase name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
- <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
@@ -1412,10 +1401,10 @@ Matchers.tests.cpp:<line number>
<testCase name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" duration="{duration}"/>
- <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" duration="{duration}"/>
+ <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
- <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" duration="{duration}"/>
+ <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
@@ -1425,13 +1414,33 @@ Matchers.tests.cpp:<line number>
<testCase name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
- <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" duration="{duration}"/>
- <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>
@@ -1445,20 +1454,20 @@ Matchers.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="FAIL does not require an argument" duration="{duration}">
<failure message="FAIL()">
FAILED:
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="FAIL_CHECK does not abort the test" duration="{duration}">
<failure message="FAIL_CHECK()">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="INFO and WARN do not abort tests" duration="{duration}"/>
@@ -1470,7 +1479,7 @@ with expansion:
2 == 1
this message should be logged
so should this
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="INFO gets logged on failure, even if captured before successful assertions" duration="{duration}">
@@ -1481,7 +1490,7 @@ with expansion:
2 == 1
this message may be logged later
this message should be logged
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="CHECK(a == 0)">
FAILED:
@@ -1491,7 +1500,7 @@ with expansion:
this message may be logged later
this message should be logged
and this, but later
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="INFO is reset for each loop" duration="{duration}">
@@ -1502,21 +1511,21 @@ with expansion:
10 < 10
current counter 10
i := 10
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Output from all sections is reported/one" duration="{duration}">
<failure message="FAIL()">
FAILED:
Message from section one
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Output from all sections is reported/two" duration="{duration}">
<failure message="FAIL()">
FAILED:
Message from section two
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="SUCCEED counts as a test pass" duration="{duration}"/>
@@ -1527,14 +1536,14 @@ Message.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
Previous info should not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="just failure after unscoped info" duration="{duration}">
<failure message="FAIL()">
FAILED:
previous unscoped info SHOULD not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="mix info, unscoped info and warning" duration="{duration}"/>
@@ -1543,7 +1552,7 @@ Message.tests.cpp:<line number>
FAILED:
REQUIRE( false )
this SHOULD be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="print unscoped info if passing unscoped info is printed" duration="{duration}"/>
@@ -1553,7 +1562,7 @@ FAILED:
REQUIRE( false )
this SHOULD be seen
this SHOULD also be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="prints unscoped info only for the first assertion" duration="{duration}">
@@ -1561,7 +1570,7 @@ Message.tests.cpp:<line number>
FAILED:
CHECK( false )
this SHOULD be seen only ONCE
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="sends information to INFO" duration="{duration}">
@@ -1570,7 +1579,7 @@ FAILED:
REQUIRE( false )
hi
i := 7
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="stacks unscoped info in loops" duration="{duration}">
@@ -1581,7 +1590,7 @@ Count 1 to 3...
1
2
3
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="CHECK(false)">
FAILED:
@@ -1590,7 +1599,7 @@ Count 4 to 6...
4
5
6
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
</file>
@@ -1606,7 +1615,7 @@ FAILED:
CHECK( f() == 0 )
with expansion:
1 == 0
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="#961 -- Dynamically created sections should all be reported/Looped section 0" duration="{duration}"/>
@@ -1626,7 +1635,7 @@ Misc.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
to infinity and beyond
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A couple of nested sections followed by a failure/Outer/Inner" duration="{duration}"/>
@@ -1650,7 +1659,7 @@ with expansion:
$a = 20;
}
"
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0" duration="{duration}"/>
@@ -1712,13 +1721,13 @@ Misc.tests.cpp:<line number>
<testCase name="Testing checked-if 2" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Testing checked-if 3" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="This test 'should' fail but doesn't" duration="{duration}"/>
@@ -1729,7 +1738,7 @@ FAILED:
REQUIRE( testCheckedElse( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="checkedIf" duration="{duration}"/>
@@ -1739,7 +1748,7 @@ FAILED:
REQUIRE( testCheckedIf( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="even more nested SECTION tests/c/d (leaf)" duration="{duration}"/>
@@ -1752,7 +1761,7 @@ FAILED:
CHECK( b > a )
with expansion:
0 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="looped SECTION tests/b is currently: 1" duration="{duration}">
@@ -1761,7 +1770,7 @@ FAILED:
CHECK( b > a )
with expansion:
1 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="looped SECTION tests/b is currently: 2" duration="{duration}"/>
@@ -1779,7 +1788,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[0] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1787,7 +1796,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[1] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1795,7 +1804,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[3] (3) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1803,7 +1812,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[4] (5) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1811,7 +1820,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[6] (13) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1819,7 +1828,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[7] (21) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="more nested SECTION tests/equal/doesn't equal" duration="{duration}">
@@ -1828,7 +1837,7 @@ FAILED:
REQUIRE( a == b )
with expansion:
1 == 2
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="more nested SECTION tests/doesn't equal/not equal" duration="{duration}"/>
@@ -1844,7 +1853,7 @@ Misc.tests.cpp:<line number>
FAILED:
REQUIRE( false )
3
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="toString on const wchar_t const pointer returns the string contents" duration="{duration}"/>
@@ -1860,6 +1869,102 @@ Misc.tests.cpp:<line number>
<testCase name="xmlentitycheck/embedded xml: <test>it should be possible to embed xml characters, such as <, " or &, or even whole <xml>documents</xml> within an attribute</test>" duration="{duration}"/>
<testCase name="xmlentitycheck/encoded chars: these should all be encoded: &&&"""<<<&"<<&"" duration="{duration}"/>
</file>
+ <file path="tests/<exe-name>/UsageTests/Skip.tests.cpp">
+ <testCase name="Empty generators can SKIP in constructor" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+This generator is empty
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="a succeeding test can still be skipped" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="dynamic skipping works with generators" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+skipping because answer = 41
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failed assertions before SKIP cause test case to fail" duration="{duration}">
+ <skipped message="CHECK(3 == 4)">
+FAILED:
+ CHECK( 3 == 4 )
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failing for some generator values causes entire test case to fail" duration="{duration}">
+ <skipped message="FAIL()">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="FAIL()">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failing in some unskipped sections causes entire test case to fail/skipped" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failing in some unskipped sections causes entire test case to fail/not skipped" duration="{duration}">
+ <skipped message="FAIL()">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="nested sections can be skipped dynamically at runtime/B2/B" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="nested sections can be skipped dynamically at runtime/B" duration="{duration}"/>
+ <testCase name="sections can be skipped dynamically at runtime/not skipped" duration="{duration}"/>
+ <testCase name="sections can be skipped dynamically at runtime/skipped" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="sections can be skipped dynamically at runtime/also not skipped" duration="{duration}"/>
+ <testCase name="skipped tests can optionally provide a reason" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="tests can be skipped dynamically at runtime" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ </file>
<file path="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp">
<testCase name="Stringifying std::chrono::duration helpers" duration="{duration}"/>
<testCase name="Stringifying std::chrono::duration with weird ratios" duration="{duration}"/>
@@ -1921,7 +2026,7 @@ Misc.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
1514
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="(unimplemented) static bools can be evaluated/compare to true" duration="{duration}"/>
@@ -1935,14 +2040,14 @@ FAILED:
CHECK( &o1 == &o2 )
with expansion:
0x<hex digits> == 0x<hex digits>
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
<failure message="CHECK(o1 == o2)">
FAILED:
CHECK( o1 == o2 )
with expansion:
{?} == {?}
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="An expression with side-effects should only be evaluated once" duration="{duration}"/>
diff --git a/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
index 97b2d988175f0bf3ff007e9364015e972e9dbb52..3509287f788c0346c0681014e08e1c7fdb182223 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
-<!-- rng-seed=1 -->
+<!-- filters='"*" ~[!nonportable] ~[!benchmark] ~[approvals]' rng-seed=1 -->
<testExecutions version="1">
<file path="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp">
<testCase name="Clara::Arg supports single-arg parse the way Opt does" duration="{duration}"/>
@@ -8,44 +8,6 @@
<testCase name="is_unary_function" duration="{duration}"/>
</file>
<file path="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp">
- <testCase name="#1905 -- test spec parser properly clears internal state between compound tests" duration="{duration}"/>
- <testCase name="#1912 -- test spec parser handles escaping/Various parentheses" duration="{duration}"/>
- <testCase name="#1912 -- test spec parser handles escaping/backslash in test name" duration="{duration}"/>
- <testCase name="Parse test names and tags/Empty test spec should have no filters" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from empty string should have no filters" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from just a comma should have no filters" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from name should have one filter" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from quoted name should have one filter" duration="{duration}"/>
- <testCase name="Parse test names and tags/Test spec from name should have one filter" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at the start" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at the end" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at both ends" duration="{duration}"/>
- <testCase name="Parse test names and tags/Redundant wildcard at the start" duration="{duration}"/>
- <testCase name="Parse test names and tags/Redundant wildcard at the end" duration="{duration}"/>
- <testCase name="Parse test names and tags/Redundant wildcard at both ends" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcard at both ends, redundant at start" duration="{duration}"/>
- <testCase name="Parse test names and tags/Just wildcard" duration="{duration}"/>
- <testCase name="Parse test names and tags/Single tag" duration="{duration}"/>
- <testCase name="Parse test names and tags/Single tag, two matches" duration="{duration}"/>
- <testCase name="Parse test names and tags/Two tags" duration="{duration}"/>
- <testCase name="Parse test names and tags/Two tags, spare separated" duration="{duration}"/>
- <testCase name="Parse test names and tags/Wildcarded name and tag" duration="{duration}"/>
- <testCase name="Parse test names and tags/Single tag exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/One tag exclusion and one tag inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/One tag exclusion and one wldcarded name inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/One tag exclusion, using exclude:, and one wldcarded name inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/name exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/wildcarded name exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/wildcarded name exclusion with tag inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/wildcarded name exclusion, using exclude:, with tag inclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/two wildcarded names" duration="{duration}"/>
- <testCase name="Parse test names and tags/empty tag" duration="{duration}"/>
- <testCase name="Parse test names and tags/empty quoted name" duration="{duration}"/>
- <testCase name="Parse test names and tags/quoted string followed by tag exclusion" duration="{duration}"/>
- <testCase name="Parse test names and tags/Leading and trailing spaces in test spec" duration="{duration}"/>
- <testCase name="Parse test names and tags/Leading and trailing spaces in test name" duration="{duration}"/>
- <testCase name="Parse test names and tags/Shortened hide tags are split apart when parsing" duration="{duration}"/>
- <testCase name="Parse test names and tags/Shortened hide tags also properly handle exclusion" duration="{duration}"/>
<testCase name="Parsing sharding-related cli flags/shard-count" duration="{duration}"/>
<testCase name="Parsing sharding-related cli flags/Negative shard count reports error" duration="{duration}"/>
<testCase name="Parsing sharding-related cli flags/Zero shard count reports error" duration="{duration}"/>
@@ -108,6 +70,7 @@
<testCase name="convertToBits" duration="{duration}"/>
</file>
<file path="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp">
+ <testCase name="Filter generator throws exception for empty generator" duration="{duration}"/>
<testCase name="Generators internals/Single value" duration="{duration}"/>
<testCase name="Generators internals/Preset values" duration="{duration}"/>
<testCase name="Generators internals/Generator combinator" duration="{duration}"/>
@@ -156,6 +119,10 @@
<testCase name="warmup" duration="{duration}"/>
<testCase name="weighted_average_quantile" duration="{duration}"/>
</file>
+ <file path="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp">
+ <testCase name="Parse uints/proper inputs" duration="{duration}"/>
+ <testCase name="Parse uints/Bad inputs" duration="{duration}"/>
+ </file>
<file path="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp">
<testCase name="#1938 - GENERATE after a section/A" duration="{duration}"/>
<testCase name="#1938 - GENERATE after a section/B" duration="{duration}"/>
@@ -265,7 +232,6 @@
<testCase name="startsWith" duration="{duration}"/>
</file>
<file path="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp">
- <testCase name="Empty tag is not allowed" duration="{duration}"/>
<testCase name="Tag alias can be registered against tag patterns/The same tag alias can only be registered once" duration="{duration}"/>
<testCase name="Tag alias can be registered against tag patterns/Tag aliases must be of the form [@name]" duration="{duration}"/>
<testCase name="Tags with spaces and non-alphanumerical characters are accepted" duration="{duration}"/>
@@ -282,6 +248,11 @@
<testCase name="Hashing different test cases produces different result/Different tags" duration="{duration}"/>
<testCase name="Hashing test case produces same hash across multiple calls" duration="{duration}"/>
</file>
+ <file path="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp">
+ <testCase name="#1905 -- test spec parser properly clears internal state between compound tests" duration="{duration}"/>
+ <testCase name="#1912 -- test spec parser handles escaping/Various parentheses" duration="{duration}"/>
+ <testCase name="#1912 -- test spec parser handles escaping/backslash in test name" duration="{duration}"/>
+ </file>
<file path="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp">
<testCase name="Parsed tags are matched case insensitive" duration="{duration}"/>
<testCase name="Parsing tags with non-alphabetical characters is pass-through" duration="{duration}"/>
@@ -358,7 +329,7 @@ FAILED:
REQUIRE( s == "world" )
with expansion:
"hello" == "world"
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A METHOD_AS_TEST_CASE based test run that succeeds" duration="{duration}"/>
@@ -368,7 +339,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>" duration="{duration}">
@@ -377,7 +348,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>" duration="{duration}">
@@ -386,7 +357,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>" duration="{duration}">
@@ -395,7 +366,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )
with expansion:
0 == 1
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>" duration="{duration}"/>
@@ -408,7 +379,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>" duration="{duration}">
@@ -417,7 +388,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>" duration="{duration}">
@@ -426,7 +397,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
6 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>" duration="{duration}">
@@ -435,7 +406,7 @@ FAILED:
REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )
with expansion:
2 < 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>" duration="{duration}"/>
@@ -448,7 +419,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - float" duration="{duration}">
@@ -457,7 +428,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1.0f == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - int" duration="{duration}">
@@ -466,7 +437,7 @@ FAILED:
REQUIRE( Template_Fixture<TestType>::m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double" duration="{duration}"/>
@@ -478,7 +449,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
1 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3" duration="{duration}">
@@ -487,7 +458,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
3 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6" duration="{duration}">
@@ -496,7 +467,7 @@ FAILED:
REQUIRE( Nttp_Fixture<V>::value == 0 )
with expansion:
6 == 0
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1" duration="{duration}"/>
@@ -508,7 +479,7 @@ FAILED:
REQUIRE( m_a == 2 )
with expansion:
1 == 2
-Class.tests.cpp:<line number>
+at Class.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A TEST_CASE_METHOD based test run that succeeds" duration="{duration}"/>
@@ -536,52 +507,52 @@ Class.tests.cpp:<line number>
<failure message="CHECK(false != false)">
FAILED:
CHECK( false != false )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(true != true)">
FAILED:
CHECK( true != true )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(!true)">
FAILED:
CHECK( !true )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK_FALSE(!(true))">
FAILED:
CHECK_FALSE( true )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(!trueValue)">
FAILED:
CHECK( !trueValue )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK_FALSE(!(trueValue))">
FAILED:
CHECK_FALSE( trueValue )
with expansion:
!true
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(!(1 == 1))">
FAILED:
CHECK( !(1 == 1) )
with expansion:
false
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK_FALSE(!(1 == 1))">
FAILED:
CHECK_FALSE( 1 == 1 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="'Not' checks that should succeed" duration="{duration}"/>
@@ -594,91 +565,91 @@ FAILED:
CHECK( data.int_seven == 6 )
with expansion:
7 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.int_seven == 8)">
FAILED:
CHECK( data.int_seven == 8 )
with expansion:
7 == 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.int_seven == 0)">
FAILED:
CHECK( data.int_seven == 0 )
with expansion:
7 == 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 9.11f ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.11f ) )
with expansion:
9.1f == Approx( 9.1099996567 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 9.0f ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 9.0f ) )
with expansion:
9.1f == Approx( 9.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 1 ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 1 ) )
with expansion:
9.1f == Approx( 1.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one == Approx( 0 ))">
FAILED:
CHECK( data.float_nine_point_one == Approx( 0 ) )
with expansion:
9.1f == Approx( 0.0 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.double_pi == Approx( 3.1415 ))">
FAILED:
CHECK( data.double_pi == Approx( 3.1415 ) )
with expansion:
3.1415926535 == Approx( 3.1415 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello == "goodbye")">
FAILED:
CHECK( data.str_hello == "goodbye" )
with expansion:
"hello" == "goodbye"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello == "hell")">
FAILED:
CHECK( data.str_hello == "hell" )
with expansion:
"hello" == "hell"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello == "hello1")">
FAILED:
CHECK( data.str_hello == "hello1" )
with expansion:
"hello" == "hello1"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello.size() == 6)">
FAILED:
CHECK( data.str_hello.size() == 6 )
with expansion:
5 == 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(x == Approx( 1.301 ))">
FAILED:
CHECK( x == Approx( 1.301 ) )
with expansion:
1.3 == Approx( 1.301 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Equality checks that should succeed" duration="{duration}"/>
@@ -688,60 +659,60 @@ FAILED:
CHECK( data.int_seven != 7 )
with expansion:
7 != 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.float_nine_point_one != Approx( 9.1f ))">
FAILED:
CHECK( data.float_nine_point_one != Approx( 9.1f ) )
with expansion:
9.1f != Approx( 9.1000003815 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.double_pi != Approx( 3.1415926535 ))">
FAILED:
CHECK( data.double_pi != Approx( 3.1415926535 ) )
with expansion:
3.1415926535 != Approx( 3.1415926535 )
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello != "hello")">
FAILED:
CHECK( data.str_hello != "hello" )
with expansion:
"hello" != "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
<skipped message="CHECK(data.str_hello.size() != 5)">
FAILED:
CHECK( data.str_hello.size() != 5 )
with expansion:
5 != 5
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Inequality checks that should succeed" duration="{duration}"/>
<testCase name="Mayfail test case with nested sections/1/A" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Mayfail test case with nested sections/2/A" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Mayfail test case with nested sections/1/B" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Mayfail test case with nested sections/2/B" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Ordering comparison checks that should fail" duration="{duration}">
@@ -750,133 +721,133 @@ FAILED:
CHECK( data.int_seven > 7 )
with expansion:
7 > 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < 7)">
FAILED:
CHECK( data.int_seven < 7 )
with expansion:
7 < 7
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven > 8)">
FAILED:
CHECK( data.int_seven > 8 )
with expansion:
7 > 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < 6)">
FAILED:
CHECK( data.int_seven < 6 )
with expansion:
7 < 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < 0)">
FAILED:
CHECK( data.int_seven < 0 )
with expansion:
7 < 0
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven < -1)">
FAILED:
CHECK( data.int_seven < -1 )
with expansion:
7 < -1
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven >= 8)">
FAILED:
CHECK( data.int_seven >= 8 )
with expansion:
7 >= 8
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.int_seven <= 6)">
FAILED:
CHECK( data.int_seven <= 6 )
with expansion:
7 <= 6
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.float_nine_point_one < 9)">
FAILED:
CHECK( data.float_nine_point_one < 9 )
with expansion:
9.1f < 9
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.float_nine_point_one > 10)">
FAILED:
CHECK( data.float_nine_point_one > 10 )
with expansion:
9.1f > 10
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.float_nine_point_one > 9.2)">
FAILED:
CHECK( data.float_nine_point_one > 9.2 )
with expansion:
9.1f > 9.2
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello > "hello")">
FAILED:
CHECK( data.str_hello > "hello" )
with expansion:
"hello" > "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello < "hello")">
FAILED:
CHECK( data.str_hello < "hello" )
with expansion:
"hello" < "hello"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello > "hellp")">
FAILED:
CHECK( data.str_hello > "hellp" )
with expansion:
"hello" > "hellp"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello > "z")">
FAILED:
CHECK( data.str_hello > "z" )
with expansion:
"hello" > "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello < "hellm")">
FAILED:
CHECK( data.str_hello < "hellm" )
with expansion:
"hello" < "hellm"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello < "a")">
FAILED:
CHECK( data.str_hello < "a" )
with expansion:
"hello" < "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello >= "z")">
FAILED:
CHECK( data.str_hello >= "z" )
with expansion:
"hello" >= "z"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
<failure message="CHECK(data.str_hello <= "a")">
FAILED:
CHECK( data.str_hello <= "a" )
with expansion:
"hello" <= "a"
-Condition.tests.cpp:<line number>
+at Condition.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Ordering comparison checks that should succeed" duration="{duration}"/>
@@ -891,7 +862,7 @@ FAILED:
CHECK( truthy(false) )
with expansion:
Hey, its truthy!
-Decomposition.tests.cpp:<line number>
+at Decomposition.tests.cpp:<line number>
</failure>
</testCase>
</file>
@@ -909,7 +880,7 @@ Decomposition.tests.cpp:<line number>
FAILED:
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="#748 - captures with unexpected exceptions/inside REQUIRE_NOTHROW" duration="{duration}">
@@ -918,7 +889,7 @@ FAILED:
REQUIRE_NOTHROW( thisThrows() )
expected exception
answer := 42
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="#748 - captures with unexpected exceptions/inside REQUIRE_THROWS" duration="{duration}"/>
@@ -927,7 +898,7 @@ Exception.tests.cpp:<line number>
FAILED:
{Unknown expression after the reported line}
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Custom exceptions can be translated when testing for nothrow" duration="{duration}">
@@ -935,7 +906,7 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE_NOTHROW( throwCustom() )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Custom exceptions can be translated when testing for throwing as something else" duration="{duration}">
@@ -943,14 +914,14 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE_THROWS_AS( throwCustom(), std::exception )
custom exception - not std
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Custom std-exceptions can be custom translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
custom std exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Exception messages can be tested for/exact match" duration="{duration}"/>
@@ -961,18 +932,18 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK_THROWS_AS( thisThrows(), std::string )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
<failure message="CHECK_THROWS_AS(thisDoesntThrow(), std::domain_error)">
FAILED:
CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
<error message="CHECK_NOTHROW(thisThrows())">
FAILED:
CHECK_NOTHROW( thisThrows() )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Mismatching exception messages failing the test" duration="{duration}">
@@ -981,28 +952,28 @@ FAILED:
REQUIRE_THROWS_WITH( thisThrows(), "should fail" )
with expansion:
"expected exception" equals: "should fail"
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Non-std exceptions can be translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
custom exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Thrown string literals are translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
For some reason someone is throwing a string literal!
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Unexpected exceptions can be translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
3.14
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When checked exceptions are thrown they can be expected or unexpected" duration="{duration}"/>
@@ -1010,7 +981,7 @@ Exception.tests.cpp:<line number>
<error message="TEST_CASE()">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown during a CHECK the test should continue" duration="{duration}">
@@ -1018,7 +989,7 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown during a REQUIRE the test should abort fail" duration="{duration}">
@@ -1026,7 +997,7 @@ Exception.tests.cpp:<line number>
FAILED:
REQUIRE( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown from functions they are always failures" duration="{duration}">
@@ -1034,27 +1005,34 @@ Exception.tests.cpp:<line number>
FAILED:
CHECK( thisThrows() == 0 )
expected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="When unchecked exceptions are thrown from sections they are always failures/section name" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
unexpected exception
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
<testCase name="thrown std::strings are translated" duration="{duration}">
<error message="TEST_CASE()">
FAILED:
Why would you throw a std::string?
-Exception.tests.cpp:<line number>
+at Exception.tests.cpp:<line number>
</error>
</testCase>
</file>
<file path="tests/<exe-name>/UsageTests/Generators.tests.cpp">
<testCase name="#1913 - GENERATE inside a for loop should not keep recreating the generator" duration="{duration}"/>
<testCase name="#1913 - GENERATEs can share a line" duration="{duration}"/>
+ <testCase name="#2615 - Throwing in constructor generator fails test case but does not abort" duration="{duration}">
+ <skipped message="TEST_CASE()">
+FAILED:
+failure to init
+at Generators.tests.cpp:<line number>
+ </skipped>
+ </testCase>
<testCase name="3x3x3 ints" duration="{duration}"/>
<testCase name="Copy and then generate a range/from var and iterators" duration="{duration}"/>
<testCase name="Copy and then generate a range/From a temporary container" duration="{duration}"/>
@@ -1098,14 +1076,14 @@ FAILED:
CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" contains: "not there" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), ContainsSubstring( "STRING" ))">
FAILED:
CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )
with expansion:
"this string contains 'abc' as a substring" contains: "STRING"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="EndsWith string matcher" duration="{duration}">
@@ -1114,14 +1092,14 @@ FAILED:
CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )
with expansion:
"this string contains 'abc' as a substring" ends with: "Substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ))">
FAILED:
CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" ends with: "this" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Equals" duration="{duration}"/>
@@ -1131,26 +1109,26 @@ FAILED:
CHECK_THAT( testStringForMatching(), Equals( "this string contains 'ABC' as a substring" ) )
with expansion:
"this string contains 'abc' as a substring" equals: "this string contains 'ABC' as a substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ))">
FAILED:
CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" equals: "something else" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Exception matchers that fail/No exception" duration="{duration}">
<failure message="CHECK_THROWS_MATCHES(doesNotThrow(), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="REQUIRE_THROWS_MATCHES(doesNotThrow(), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Exception matchers that fail/Type mismatch" duration="{duration}">
@@ -1158,13 +1136,13 @@ Matchers.tests.cpp:<line number>
FAILED:
CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
<error message="REQUIRE_THROWS_MATCHES(throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )
Unknown exception
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</error>
</testCase>
<testCase name="Exception matchers that fail/Contents are wrong" duration="{duration}">
@@ -1173,17 +1151,18 @@ FAILED:
CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="REQUIRE_THROWS_MATCHES(throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 })">
FAILED:
REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )
with expansion:
SpecialException::what special exception has value of 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Exception matchers that succeed" duration="{duration}"/>
+ <testCase name="Exception message can be matched" duration="{duration}"/>
<testCase name="Exceptions matchers" duration="{duration}"/>
<testCase name="Floating point matchers: double/Relative" duration="{duration}"/>
<testCase name="Floating point matchers: double/Relative/Some subnormal values" duration="{duration}"/>
@@ -1191,12 +1170,14 @@ Matchers.tests.cpp:<line number>
<testCase name="Floating point matchers: double/ULPs" duration="{duration}"/>
<testCase name="Floating point matchers: double/Composed" duration="{duration}"/>
<testCase name="Floating point matchers: double/Constructor validation" duration="{duration}"/>
+ <testCase name="Floating point matchers: double/IsNaN" duration="{duration}"/>
<testCase name="Floating point matchers: float/Relative" duration="{duration}"/>
<testCase name="Floating point matchers: float/Relative/Some subnormal values" duration="{duration}"/>
<testCase name="Floating point matchers: float/Margin" duration="{duration}"/>
<testCase name="Floating point matchers: float/ULPs" duration="{duration}"/>
<testCase name="Floating point matchers: float/Composed" duration="{duration}"/>
<testCase name="Floating point matchers: float/Constructor validation" duration="{duration}"/>
+ <testCase name="Floating point matchers: float/IsNaN" duration="{duration}"/>
<testCase name="Matchers can be (AllOf) composed with the && operator" duration="{duration}"/>
<testCase name="Matchers can be (AnyOf) composed with the || operator" duration="{duration}"/>
<testCase name="Matchers can be composed with both && and ||" duration="{duration}"/>
@@ -1206,7 +1187,7 @@ FAILED:
CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) || ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )
with expansion:
"this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Matchers can be negated (Not) with the ! operator" duration="{duration}"/>
@@ -1216,7 +1197,7 @@ FAILED:
CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )
with expansion:
"this string contains 'abc' as a substring" not contains: "substring"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Overloaded comma or address-of operators are not used" duration="{duration}"/>
@@ -1227,21 +1208,21 @@ FAILED:
CHECK_THAT( testStringForMatching(), Matches( "this STRING contains 'abc' as a substring" ) )
with expansion:
"this string contains 'abc' as a substring" matches "this STRING contains 'abc' as a substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), Matches( "contains 'abc' as a substring" ))">
FAILED:
CHECK_THAT( testStringForMatching(), Matches( "contains 'abc' as a substring" ) )
with expansion:
"this string contains 'abc' as a substring" matches "contains 'abc' as a substring" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), Matches( "this string contains 'abc' as a" ))">
FAILED:
CHECK_THAT( testStringForMatching(), Matches( "this string contains 'abc' as a" ) )
with expansion:
"this string contains 'abc' as a substring" matches "this string contains 'abc' as a" case sensitively
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Regression test #1" duration="{duration}"/>
@@ -1251,14 +1232,14 @@ FAILED:
CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )
with expansion:
"this string contains 'abc' as a substring" starts with: "This String"
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ))">
FAILED:
CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )
with expansion:
"this string contains 'abc' as a substring" starts with: "string" (case insensitive)
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="String matchers" duration="{duration}"/>
@@ -1272,7 +1253,7 @@ FAILED:
CHECK_THAT( empty, Approx( t1 ) )
with expansion:
{ } is approx: { 1.0, 2.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector Approx matcher -- failing/Just different vectors" duration="{duration}">
@@ -1281,7 +1262,7 @@ FAILED:
CHECK_THAT( v1, Approx( v2 ) )
with expansion:
{ 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers/Contains (element)" duration="{duration}"/>
@@ -1295,14 +1276,14 @@ FAILED:
CHECK_THAT( v, VectorContains( -1 ) )
with expansion:
{ 1, 2, 3 } Contains: -1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(empty, VectorContains( 1 ))">
FAILED:
CHECK_THAT( empty, VectorContains( 1 ) )
with expansion:
{ } Contains: 1
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers that fail/Contains (vector)" duration="{duration}">
@@ -1311,14 +1292,14 @@ FAILED:
CHECK_THAT( empty, Contains( v ) )
with expansion:
{ } Contains: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(v, Contains( v2 ))">
FAILED:
CHECK_THAT( v, Contains( v2 ) )
with expansion:
{ 1, 2, 3 } Contains: { 1, 2, 4 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers that fail/Equals" duration="{duration}">
@@ -1327,28 +1308,28 @@ FAILED:
CHECK_THAT( v, Equals( v2 ) )
with expansion:
{ 1, 2, 3 } Equals: { 1, 2 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(v2, Equals( v ))">
FAILED:
CHECK_THAT( v2, Equals( v ) )
with expansion:
{ 1, 2 } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(empty, Equals( v ))">
FAILED:
CHECK_THAT( empty, Equals( v ) )
with expansion:
{ } Equals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(v, Equals( empty ))">
FAILED:
CHECK_THAT( v, Equals( empty ) )
with expansion:
{ 1, 2, 3 } Equals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Vector matchers that fail/UnorderedEquals" duration="{duration}">
@@ -1357,28 +1338,28 @@ FAILED:
CHECK_THAT( v, UnorderedEquals( empty ) )
with expansion:
{ 1, 2, 3 } UnorderedEquals: { }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(empty, UnorderedEquals( v ))">
FAILED:
CHECK_THAT( empty, UnorderedEquals( v ) )
with expansion:
{ } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(permuted, UnorderedEquals( v ))">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 1, 3 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
<failure message="CHECK_THAT(permuted, UnorderedEquals( v ))">
FAILED:
CHECK_THAT( permuted, UnorderedEquals( v ) )
with expansion:
{ 3, 1 } UnorderedEquals: { 1, 2, 3 }
-Matchers.tests.cpp:<line number>
+at Matchers.tests.cpp:<line number>
</failure>
</testCase>
</file>
@@ -1392,16 +1373,24 @@ Matchers.tests.cpp:<line number>
<testCase name="Basic use of the Empty range matcher/Simple, std-provided containers" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type with empty" duration="{duration}"/>
<testCase name="Basic use of the Empty range matcher/Type requires ADL found empty free function" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types (differ in array N)" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers of different container types and value types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Container conversions/Two equal containers, one random access, one not" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Value type/Two equal containers of different value types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Value type/Two non-equal containers of different value types" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Ranges with begin that needs ADL" duration="{duration}"/>
+ <testCase name="Type conversions of RangeEquals and similar/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Basic usage" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
- <testCase name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of AllTrue range matcher/Basic usage/One false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
- <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
@@ -1411,10 +1400,10 @@ Matchers.tests.cpp:<line number>
<testCase name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" duration="{duration}"/>
- <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" duration="{duration}"/>
+ <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
- <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" duration="{duration}"/>
+ <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evaluates to true" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
@@ -1424,13 +1413,33 @@ Matchers.tests.cpp:<line number>
<testCase name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
- <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evaluates to false" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" duration="{duration}"/>
- <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" duration="{duration}"/>
+ <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evaluates to false" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
<testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers (with same first elements)" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/Check short-circuits on failure" duration="{duration}"/>
+ <testCase name="Usage of RangeEquals range matcher/Check short-circuiting behaviour/All elements are checked on success" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container matches empty container" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Empty container does not match non-empty container" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal 1-length non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two equal-sized, non-equal, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Basic usage/Two non-equal-sized, non-empty containers" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Custom predicate/Two non-equal non-empty containers (close enough)" duration="{duration}"/>
+ <testCase name="Usage of UnorderedRangeEquals range matcher/Ranges that need ADL begin/end" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
<testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>
@@ -1444,20 +1453,20 @@ Matchers.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="FAIL does not require an argument" duration="{duration}">
<failure message="FAIL()">
FAILED:
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="FAIL_CHECK does not abort the test" duration="{duration}">
<failure message="FAIL_CHECK()">
FAILED:
This is a failure
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="INFO and WARN do not abort tests" duration="{duration}"/>
@@ -1469,7 +1478,7 @@ with expansion:
2 == 1
this message should be logged
so should this
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="INFO gets logged on failure, even if captured before successful assertions" duration="{duration}">
@@ -1480,7 +1489,7 @@ with expansion:
2 == 1
this message may be logged later
this message should be logged
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="CHECK(a == 0)">
FAILED:
@@ -1490,7 +1499,7 @@ with expansion:
this message may be logged later
this message should be logged
and this, but later
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="INFO is reset for each loop" duration="{duration}">
@@ -1501,21 +1510,21 @@ with expansion:
10 < 10
current counter 10
i := 10
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Output from all sections is reported/one" duration="{duration}">
<failure message="FAIL()">
FAILED:
Message from section one
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Output from all sections is reported/two" duration="{duration}">
<failure message="FAIL()">
FAILED:
Message from section two
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="SUCCEED counts as a test pass" duration="{duration}"/>
@@ -1526,14 +1535,14 @@ Message.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
Previous info should not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="just failure after unscoped info" duration="{duration}">
<failure message="FAIL()">
FAILED:
previous unscoped info SHOULD not be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="mix info, unscoped info and warning" duration="{duration}"/>
@@ -1542,7 +1551,7 @@ Message.tests.cpp:<line number>
FAILED:
REQUIRE( false )
this SHOULD be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="print unscoped info if passing unscoped info is printed" duration="{duration}"/>
@@ -1552,7 +1561,7 @@ FAILED:
REQUIRE( false )
this SHOULD be seen
this SHOULD also be seen
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="prints unscoped info only for the first assertion" duration="{duration}">
@@ -1560,7 +1569,7 @@ Message.tests.cpp:<line number>
FAILED:
CHECK( false )
this SHOULD be seen only ONCE
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="sends information to INFO" duration="{duration}">
@@ -1569,7 +1578,7 @@ FAILED:
REQUIRE( false )
hi
i := 7
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="stacks unscoped info in loops" duration="{duration}">
@@ -1580,7 +1589,7 @@ Count 1 to 3...
1
2
3
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
<failure message="CHECK(false)">
FAILED:
@@ -1589,7 +1598,7 @@ Count 4 to 6...
4
5
6
-Message.tests.cpp:<line number>
+at Message.tests.cpp:<line number>
</failure>
</testCase>
</file>
@@ -1605,7 +1614,7 @@ FAILED:
CHECK( f() == 0 )
with expansion:
1 == 0
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="#961 -- Dynamically created sections should all be reported/Looped section 0" duration="{duration}"/>
@@ -1625,7 +1634,7 @@ Misc.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
to infinity and beyond
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="A couple of nested sections followed by a failure/Outer/Inner" duration="{duration}"/>
@@ -1649,7 +1658,7 @@ with expansion:
$a = 20;
}
"
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0" duration="{duration}"/>
@@ -1711,13 +1720,13 @@ Misc.tests.cpp:<line number>
<testCase name="Testing checked-if 2" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="Testing checked-if 3" duration="{duration}">
<skipped message="FAIL()">
FAILED:
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</skipped>
</testCase>
<testCase name="This test 'should' fail but doesn't" duration="{duration}"/>
@@ -1728,7 +1737,7 @@ FAILED:
REQUIRE( testCheckedElse( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="checkedIf" duration="{duration}"/>
@@ -1738,7 +1747,7 @@ FAILED:
REQUIRE( testCheckedIf( false ) )
with expansion:
false
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="even more nested SECTION tests/c/d (leaf)" duration="{duration}"/>
@@ -1751,7 +1760,7 @@ FAILED:
CHECK( b > a )
with expansion:
0 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="looped SECTION tests/b is currently: 1" duration="{duration}">
@@ -1760,7 +1769,7 @@ FAILED:
CHECK( b > a )
with expansion:
1 > 1
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="looped SECTION tests/b is currently: 2" duration="{duration}"/>
@@ -1778,7 +1787,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[0] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1786,7 +1795,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[1] (1) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1794,7 +1803,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[3] (3) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1802,7 +1811,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[4] (5) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1810,7 +1819,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[6] (13) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
<failure message="CHECK(( fib[i] % 2 ) == 0)">
FAILED:
@@ -1818,7 +1827,7 @@ FAILED:
with expansion:
1 == 0
Testing if fib[7] (21) is even
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="more nested SECTION tests/equal/doesn't equal" duration="{duration}">
@@ -1827,7 +1836,7 @@ FAILED:
REQUIRE( a == b )
with expansion:
1 == 2
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="more nested SECTION tests/doesn't equal/not equal" duration="{duration}"/>
@@ -1843,7 +1852,7 @@ Misc.tests.cpp:<line number>
FAILED:
REQUIRE( false )
3
-Misc.tests.cpp:<line number>
+at Misc.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="toString on const wchar_t const pointer returns the string contents" duration="{duration}"/>
@@ -1859,6 +1868,102 @@ Misc.tests.cpp:<line number>
<testCase name="xmlentitycheck/embedded xml: <test>it should be possible to embed xml characters, such as <, " or &, or even whole <xml>documents</xml> within an attribute</test>" duration="{duration}"/>
<testCase name="xmlentitycheck/encoded chars: these should all be encoded: &&&"""<<<&"<<&"" duration="{duration}"/>
</file>
+ <file path="tests/<exe-name>/UsageTests/Skip.tests.cpp">
+ <testCase name="Empty generators can SKIP in constructor" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+This generator is empty
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="a succeeding test can still be skipped" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="dynamic skipping works with generators" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+skipping because answer = 41
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failed assertions before SKIP cause test case to fail" duration="{duration}">
+ <skipped message="CHECK(3 == 4)">
+FAILED:
+ CHECK( 3 == 4 )
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failing for some generator values causes entire test case to fail" duration="{duration}">
+ <skipped message="FAIL()">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="FAIL()">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </skipped>
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failing in some unskipped sections causes entire test case to fail/skipped" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="failing in some unskipped sections causes entire test case to fail/not skipped" duration="{duration}">
+ <skipped message="FAIL()">
+FAILED:
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="nested sections can be skipped dynamically at runtime/B2/B" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="nested sections can be skipped dynamically at runtime/B" duration="{duration}"/>
+ <testCase name="sections can be skipped dynamically at runtime/not skipped" duration="{duration}"/>
+ <testCase name="sections can be skipped dynamically at runtime/skipped" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="sections can be skipped dynamically at runtime/also not skipped" duration="{duration}"/>
+ <testCase name="skipped tests can optionally provide a reason" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+skipping because answer = 43
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ <testCase name="tests can be skipped dynamically at runtime" duration="{duration}">
+ <skipped message="SKIP()">
+SKIPPED
+at Skip.tests.cpp:<line number>
+ </skipped>
+ </testCase>
+ </file>
<file path="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp">
<testCase name="Stringifying std::chrono::duration helpers" duration="{duration}"/>
<testCase name="Stringifying std::chrono::duration with weird ratios" duration="{duration}"/>
@@ -1920,7 +2025,7 @@ Misc.tests.cpp:<line number>
<failure message="FAIL()">
FAILED:
1514
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="(unimplemented) static bools can be evaluated/compare to true" duration="{duration}"/>
@@ -1934,14 +2039,14 @@ FAILED:
CHECK( &o1 == &o2 )
with expansion:
0x<hex digits> == 0x<hex digits>
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
<failure message="CHECK(o1 == o2)">
FAILED:
CHECK( o1 == o2 )
with expansion:
{?} == {?}
-Tricky.tests.cpp:<line number>
+at Tricky.tests.cpp:<line number>
</failure>
</testCase>
<testCase name="An expression with side-effects should only be evaluated once" duration="{duration}"/>
diff --git a/packages/Catch2/tests/SelfTest/Baselines/tap.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/tap.sw.approved.txt
index 2c7adae54de162c2d455a82333d4cc393fb727d8..acd0a1c14934133acd85defa52b363fce72ddcae 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/tap.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/tap.sw.approved.txt
@@ -1,3 +1,4 @@
+# filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
# rng-seed: 1
# # A test name that starts with a #
ok {test-number} - with 1 message: 'yay'
@@ -163,6 +164,8 @@ ok {test-number} - smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0
ok {test-number} - smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45])
# #2152 - ULP checks between differently signed values were wrong - float
ok {test-number} - smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00])
+# #2615 - Throwing in constructor generator fails test case but does not abort
+not ok {test-number} - unexpected exception with message: 'failure to init'
# #748 - captures with unexpected exceptions
not ok {test-number} - unexpected exception with message: 'answer := 42' with 1 message: 'expected exception'
# #748 - captures with unexpected exceptions
@@ -981,10 +984,10 @@ ok {test-number} - enumInfo->lookup(0) == "Value1" for: Value1 == "Value1"
ok {test-number} - enumInfo->lookup(1) == "Value2" for: Value2 == "Value2"
# Directly creating an EnumInfo
ok {test-number} - enumInfo->lookup(3) == "{** unexpected enum value **}" for: {** unexpected enum value **} == "{** unexpected enum value **}"
+# Empty generators can SKIP in constructor
+ok {test-number} - # SKIP 'This generator is empty'
# Empty stream name opens cout stream
ok {test-number} - Catch::makeStream( "" )->isConsole() for: true
-# Empty tag is not allowed
-ok {test-number} - Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
# EndsWith string matcher
not ok {test-number} - testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring"
# EndsWith string matcher
@@ -1075,6 +1078,14 @@ not ok {test-number} - throwsSpecialException( 4 ), SpecialException, ExceptionM
ok {test-number} - throwsSpecialException( 1 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
# Exception matchers that succeed
ok {test-number} - throwsSpecialException( 2 ), SpecialException, ExceptionMatcher{ 2 } for: SpecialException::what special exception has value of 2
+# Exception message can be matched
+ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) ) for: DerivedException::what matches "starts with: "Derived""
+# Exception message can be matched
+ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) ) for: DerivedException::what matches "ends with: "::what""
+# Exception message can be matched
+ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) ) for: DerivedException::what matches "not starts with: "::what""
+# Exception message can be matched
+ok {test-number} - throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) ) for: SpecialException::what matches "starts with: "Special""
# Exception messages can be tested for
ok {test-number} - thisThrows(), "expected exception" for: "expected exception" equals: "expected exception"
# Exception messages can be tested for
@@ -1119,6 +1130,8 @@ ok {test-number} - Factorial(2) == 2 for: 2 == 2
ok {test-number} - Factorial(3) == 6 for: 6 == 6
# Factorials are computed
ok {test-number} - Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+# Filter generator throws exception for empty generator
+ok {test-number} - filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
# Floating point matchers: double
ok {test-number} - 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
# Floating point matchers: double
@@ -1177,6 +1190,8 @@ ok {test-number} - WithinRel( 1., 0. )
ok {test-number} - WithinRel( 1., -0.2 ), std::domain_error
# Floating point matchers: double
ok {test-number} - WithinRel( 1., 1. ), std::domain_error
+# Floating point matchers: double
+ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN
# Floating point matchers: float
ok {test-number} - 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
# Floating point matchers: float
@@ -1241,6 +1256,8 @@ ok {test-number} - WithinRel( 1.f, 0.f )
ok {test-number} - WithinRel( 1.f, -0.2f ), std::domain_error
# Floating point matchers: float
ok {test-number} - WithinRel( 1.f, 1.f ), std::domain_error
+# Floating point matchers: float
+ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN
# Generators -- adapters
ok {test-number} - i % 2 == 0 for: 0 == 0
# Generators -- adapters
@@ -2081,308 +2098,28 @@ ok {test-number} - &EvilMatcher(), EvilAddressOfOperatorUsed
ok {test-number} - EvilMatcher() || ( EvilMatcher() && !EvilMatcher() )
# Overloaded comma or address-of operators are not used
ok {test-number} - ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher()
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - parseTestSpec( "*a" ).matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - parseTestSpec( "a*" ).matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - parseTestSpec( "*a*" ).matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) for: true
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]"))) for: !false
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("only hidden", "[.]"))) for: !false
-# Parse test names and tags
-ok {test-number} - spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")) for: true
+# Parse uints
+ok {test-number} - parseUInt( "0" ) == Optional<unsigned int>{ 0 } for: {?} == {?}
+# Parse uints
+ok {test-number} - parseUInt( "100" ) == Optional<unsigned int>{ 100 } for: {?} == {?}
+# Parse uints
+ok {test-number} - parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 } for: {?} == {?}
+# Parse uints
+ok {test-number} - parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 } for: {?} == {?}
+# Parse uints
+ok {test-number} - !(parseUInt( "" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "!!KJHF*#" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "-1" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "4294967296" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "42949672964294967296429496729642949672964294967296" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "2 4" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "0x<hex digits>", 10 )) for: !{?}
# Parsed tags are matched case insensitive
ok {test-number} - spec.hasFilters() for: true
# Parsed tags are matched case insensitive
@@ -2396,11 +2133,11 @@ ok {test-number} - config.shardCount == 8 for: 8 == 8
# Parsing sharding-related cli flags
ok {test-number} - !(result) for: !{?}
# Parsing sharding-related cli flags
-ok {test-number} - result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+ok {test-number} - result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" ) for: "Could not parse '-1' as shard count" contains: "Could not parse '-1' as shard count"
# Parsing sharding-related cli flags
ok {test-number} - !(result) for: !{?}
# Parsing sharding-related cli flags
-ok {test-number} - result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+ok {test-number} - result.errorMessage(), ContainsSubstring( "Shard count must be positive" ) for: "Shard count must be positive" contains: "Shard count must be positive"
# Parsing sharding-related cli flags
ok {test-number} - cli.parse({ "test", "--shard-index=2" }) for: {?}
# Parsing sharding-related cli flags
@@ -2408,7 +2145,7 @@ ok {test-number} - config.shardIndex == 2 for: 2 == 2
# Parsing sharding-related cli flags
ok {test-number} - !(result) for: !{?}
# Parsing sharding-related cli flags
-ok {test-number} - result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number") for: "Shard index must be a non-negative number" contains: "Shard index must be a non-negative number"
+ok {test-number} - result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" ) for: "Could not parse '-12' as shard index" contains: "Could not parse '-12' as shard index"
# Parsing sharding-related cli flags
ok {test-number} - cli.parse({ "test", "--shard-index=0" }) for: {?}
# Parsing sharding-related cli flags
@@ -3494,6 +3231,40 @@ ok {test-number} - trim(StringRef(leading_whitespace)) == StringRef(no_whitespac
ok {test-number} - trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
# Trim strings
ok {test-number} - trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
# Unexpected exceptions can be translated
not ok {test-number} - unexpected exception with message: '3.14'
# Upcasting special member functions
@@ -3704,6 +3475,70 @@ ok {test-number} - mocked.m_derefed[2] for: true
ok {test-number} - !(mocked.m_derefed[3]) for: !false
# Usage of NoneTrue range matcher
ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of RangeEquals range matcher
+ok {test-number} - empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
+# Usage of RangeEquals range matcher
+ok {test-number} - empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
+# Usage of RangeEquals range matcher
+ok {test-number} - non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
+# Usage of RangeEquals range matcher
+ok {test-number} - non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
+# Usage of RangeEquals range matcher
+ok {test-number} - array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Usage of RangeEquals range matcher
+ok {test-number} - array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
+# Usage of RangeEquals range matcher
+ok {test-number} - array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+# Usage of RangeEquals range matcher
+ok {test-number} - vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
+# Usage of RangeEquals range matcher
+ok {test-number} - needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[0] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[1] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[2] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - !(mocked1.m_derefed[3]) for: !false
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1, RangeEquals( arr ) for: { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[0] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[1] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[2] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[3] for: true
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
# Usage of the SizeIs range matcher
ok {test-number} - empty_vec, SizeIs(0) for: { } has size == 0
# Usage of the SizeIs range matcher
@@ -3880,6 +3715,10 @@ ok {test-number} - encode( "[\x01]" ) == "[\\x01]" for: "[\x01]" == "[\x01]"
ok {test-number} - encode( "[\x7F]" ) == "[\\x7F]" for: "[\x7F]" == "[\x7F]"
# XmlWriter writes boolean attributes as true/false
ok {test-number} - stream.str(), ContainsSubstring(R"(attr1="true")") && ContainsSubstring(R"(attr2="false")") for: "<?xml version="1.0" encoding="UTF-8"?> <Element1 attr1="true" attr2="false"/> " ( contains: "attr1="true"" and contains: "attr2="false"" )
+# a succeeding test can still be skipped
+ok {test-number} -
+# a succeeding test can still be skipped
+ok {test-number} - # SKIP
# analyse no analysis
ok {test-number} - analysis.mean.point.count() == 23 for: 23.0 == 23
# analyse no analysis
@@ -4050,6 +3889,12 @@ ok {test-number} - convertToBits( -0. ) == ( 1ULL << 63 ) for: 92233720368547758
ok {test-number} - convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 for: 1 == 1
# convertToBits
ok {test-number} - convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 for: 1 == 1
+# dynamic skipping works with generators
+ok {test-number} - # SKIP 'skipping because answer = 41'
+# dynamic skipping works with generators
+ok {test-number} -
+# dynamic skipping works with generators
+ok {test-number} - # SKIP 'skipping because answer = 43'
# empty tags are not allowed
ok {test-number} - Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
# erfc_inv
@@ -4068,6 +3913,22 @@ ok {test-number} -
ok {test-number} -
# even more nested SECTION tests
ok {test-number} -
+# failed assertions before SKIP cause test case to fail
+not ok {test-number} - 3 == 4
+# failed assertions before SKIP cause test case to fail
+ok {test-number} - # SKIP
+# failing for some generator values causes entire test case to fail
+not ok {test-number} - explicitly
+# failing for some generator values causes entire test case to fail
+ok {test-number} - # SKIP
+# failing for some generator values causes entire test case to fail
+not ok {test-number} - explicitly
+# failing for some generator values causes entire test case to fail
+ok {test-number} - # SKIP
+# failing in some unskipped sections causes entire test case to fail
+ok {test-number} - # SKIP
+# failing in some unskipped sections causes entire test case to fail
+not ok {test-number} - explicitly
loose text artifact
# is_unary_function
ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary1)>::value'
@@ -4177,6 +4038,11 @@ ok {test-number} - a != b for: 1 != 2
ok {test-number} - b != a for: 2 != 1
# nested SECTION tests
ok {test-number} - a != b for: 1 != 2
+a!
+b1!
+# nested sections can be skipped dynamically at runtime
+ok {test-number} - # SKIP
+!
# non streamable - with conv. op
ok {test-number} - s == "7" for: "7" == "7"
# non-copyable objects
@@ -4341,12 +4207,20 @@ ok {test-number} - Timing.elapsed >= time for: 128 ns >= 100 ns
ok {test-number} - Timing.result == Timing.iterations + 17 for: 145 == 145
# run_for_at_least, int
ok {test-number} - Timing.iterations >= time.count() for: 128 >= 100
+# sections can be skipped dynamically at runtime
+ok {test-number} -
+# sections can be skipped dynamically at runtime
+ok {test-number} - # SKIP
+# sections can be skipped dynamically at runtime
+ok {test-number} -
# send a single char to INFO
not ok {test-number} - false with 1 message: '3'
# sends information to INFO
not ok {test-number} - false with 2 messages: 'hi' and 'i := 7'
# shortened hide tags are split apart
ok {test-number} - testcase.tags, VectorContains( Tag( "magic-tag" ) ) && VectorContains( Tag( "."_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} and Contains: {?} )
+# skipped tests can optionally provide a reason
+ok {test-number} - # SKIP 'skipping because answer = 43'
# splitString
ok {test-number} - splitStringRef("", ','), Equals(std::vector<StringRef>()) for: { } Equals: { }
# splitString
@@ -4429,6 +4303,8 @@ ok {test-number} - strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(
ok {test-number} - testcase.tags.size() == 1 for: 1 == 1
# tags with dots in later positions are not parsed as hidden
ok {test-number} - testcase.tags[0].original == "magic.tag"_catch_sr for: magic.tag == magic.tag
+# tests can be skipped dynamically at runtime
+ok {test-number} - # SKIP
# thrown std::strings are translated
not ok {test-number} - unexpected exception with message: 'Why would you throw a std::string?'
# toString on const wchar_t const pointer returns the string contents
@@ -4601,5 +4477,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
ok {test-number} -
# xmlentitycheck
ok {test-number} -
-1..2299
+1..2237
diff --git a/packages/Catch2/tests/SelfTest/Baselines/tap.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
index d13b493c904716a157a80e11c1fb2a89a91d7d5c..033290497de6d943581107ed1b2026cdde1c3ccd 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
@@ -1,3 +1,4 @@
+# filters: "*" ~[!nonportable] ~[!benchmark] ~[approvals]
# rng-seed: 1
# # A test name that starts with a #
ok {test-number} - with 1 message: 'yay'
@@ -161,6 +162,8 @@ ok {test-number} - smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0
ok {test-number} - smallest_non_zero, WithinULP( -smallest_non_zero, 2 ) for: 0.0f is within 2 ULPs of -1.40129846e-45f ([-4.20389539e-45, 1.40129846e-45])
# #2152 - ULP checks between differently signed values were wrong - float
ok {test-number} - smallest_non_zero, !WithinULP( -smallest_non_zero, 1 ) for: 0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00])
+# #2615 - Throwing in constructor generator fails test case but does not abort
+not ok {test-number} - unexpected exception with message: 'failure to init'
# #748 - captures with unexpected exceptions
not ok {test-number} - unexpected exception with message: 'answer := 42' with 1 message: 'expected exception'
# #748 - captures with unexpected exceptions
@@ -979,10 +982,10 @@ ok {test-number} - enumInfo->lookup(0) == "Value1" for: Value1 == "Value1"
ok {test-number} - enumInfo->lookup(1) == "Value2" for: Value2 == "Value2"
# Directly creating an EnumInfo
ok {test-number} - enumInfo->lookup(3) == "{** unexpected enum value **}" for: {** unexpected enum value **} == "{** unexpected enum value **}"
+# Empty generators can SKIP in constructor
+ok {test-number} - # SKIP 'This generator is empty'
# Empty stream name opens cout stream
ok {test-number} - Catch::makeStream( "" )->isConsole() for: true
-# Empty tag is not allowed
-ok {test-number} - Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
# EndsWith string matcher
not ok {test-number} - testStringForMatching(), EndsWith( "Substring" ) for: "this string contains 'abc' as a substring" ends with: "Substring"
# EndsWith string matcher
@@ -1073,6 +1076,14 @@ not ok {test-number} - throwsSpecialException( 4 ), SpecialException, ExceptionM
ok {test-number} - throwsSpecialException( 1 ), SpecialException, ExceptionMatcher{ 1 } for: SpecialException::what special exception has value of 1
# Exception matchers that succeed
ok {test-number} - throwsSpecialException( 2 ), SpecialException, ExceptionMatcher{ 2 } for: SpecialException::what special exception has value of 2
+# Exception message can be matched
+ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) ) for: DerivedException::what matches "starts with: "Derived""
+# Exception message can be matched
+ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) ) for: DerivedException::what matches "ends with: "::what""
+# Exception message can be matched
+ok {test-number} - throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) ) for: DerivedException::what matches "not starts with: "::what""
+# Exception message can be matched
+ok {test-number} - throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) ) for: SpecialException::what matches "starts with: "Special""
# Exception messages can be tested for
ok {test-number} - thisThrows(), "expected exception" for: "expected exception" equals: "expected exception"
# Exception messages can be tested for
@@ -1117,6 +1128,8 @@ ok {test-number} - Factorial(2) == 2 for: 2 == 2
ok {test-number} - Factorial(3) == 6 for: 6 == 6
# Factorials are computed
ok {test-number} - Factorial(10) == 3628800 for: 3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
+# Filter generator throws exception for empty generator
+ok {test-number} - filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
# Floating point matchers: double
ok {test-number} - 10., WithinRel( 11.1, 0.1 ) for: 10.0 and 11.1 are within 10% of each other
# Floating point matchers: double
@@ -1175,6 +1188,8 @@ ok {test-number} - WithinRel( 1., 0. )
ok {test-number} - WithinRel( 1., -0.2 ), std::domain_error
# Floating point matchers: double
ok {test-number} - WithinRel( 1., 1. ), std::domain_error
+# Floating point matchers: double
+ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN
# Floating point matchers: float
ok {test-number} - 10.f, WithinRel( 11.1f, 0.1f ) for: 10.0f and 11.1 are within 10% of each other
# Floating point matchers: float
@@ -1239,6 +1254,8 @@ ok {test-number} - WithinRel( 1.f, 0.f )
ok {test-number} - WithinRel( 1.f, -0.2f ), std::domain_error
# Floating point matchers: float
ok {test-number} - WithinRel( 1.f, 1.f ), std::domain_error
+# Floating point matchers: float
+ok {test-number} - 1., !IsNaN() for: 1.0 not is NaN
# Generators -- adapters
ok {test-number} - i % 2 == 0 for: 0 == 0
# Generators -- adapters
@@ -2079,308 +2096,28 @@ ok {test-number} - &EvilMatcher(), EvilAddressOfOperatorUsed
ok {test-number} - EvilMatcher() || ( EvilMatcher() && !EvilMatcher() )
# Overloaded comma or address-of operators are not used
ok {test-number} - ( EvilMatcher() && EvilMatcher() ) || !EvilMatcher()
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - parseTestSpec( "*a" ).matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - parseTestSpec( "a*" ).matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - parseTestSpec( "*a*" ).matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.hasFilters() == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcA ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcB ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcC ) == false for: false == false
-# Parse test names and tags
-ok {test-number} - spec.matches( *tcD ) == true for: true == true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( " aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark " ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches( *fakeTestCase( "aardvark" ) ) for: true
-# Parse test names and tags
-ok {test-number} - spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")) for: true
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]"))) for: !false
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("only foo", "[foo]"))) for: !false
-# Parse test names and tags
-ok {test-number} - !(spec.matches(*fakeTestCase("only hidden", "[.]"))) for: !false
-# Parse test names and tags
-ok {test-number} - spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")) for: true
+# Parse uints
+ok {test-number} - parseUInt( "0" ) == Optional<unsigned int>{ 0 } for: {?} == {?}
+# Parse uints
+ok {test-number} - parseUInt( "100" ) == Optional<unsigned int>{ 100 } for: {?} == {?}
+# Parse uints
+ok {test-number} - parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 } for: {?} == {?}
+# Parse uints
+ok {test-number} - parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 } for: {?} == {?}
+# Parse uints
+ok {test-number} - !(parseUInt( "" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "!!KJHF*#" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "-1" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "4294967296" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "42949672964294967296429496729642949672964294967296" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "2 4" )) for: !{?}
+# Parse uints
+ok {test-number} - !(parseUInt( "0x<hex digits>", 10 )) for: !{?}
# Parsed tags are matched case insensitive
ok {test-number} - spec.hasFilters() for: true
# Parsed tags are matched case insensitive
@@ -2394,11 +2131,11 @@ ok {test-number} - config.shardCount == 8 for: 8 == 8
# Parsing sharding-related cli flags
ok {test-number} - !(result) for: !{?}
# Parsing sharding-related cli flags
-ok {test-number} - result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+ok {test-number} - result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" ) for: "Could not parse '-1' as shard count" contains: "Could not parse '-1' as shard count"
# Parsing sharding-related cli flags
ok {test-number} - !(result) for: !{?}
# Parsing sharding-related cli flags
-ok {test-number} - result.errorMessage(), ContainsSubstring("Shard count must be a positive number") for: "Shard count must be a positive number" contains: "Shard count must be a positive number"
+ok {test-number} - result.errorMessage(), ContainsSubstring( "Shard count must be positive" ) for: "Shard count must be positive" contains: "Shard count must be positive"
# Parsing sharding-related cli flags
ok {test-number} - cli.parse({ "test", "--shard-index=2" }) for: {?}
# Parsing sharding-related cli flags
@@ -2406,7 +2143,7 @@ ok {test-number} - config.shardIndex == 2 for: 2 == 2
# Parsing sharding-related cli flags
ok {test-number} - !(result) for: !{?}
# Parsing sharding-related cli flags
-ok {test-number} - result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number") for: "Shard index must be a non-negative number" contains: "Shard index must be a non-negative number"
+ok {test-number} - result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" ) for: "Could not parse '-12' as shard index" contains: "Could not parse '-12' as shard index"
# Parsing sharding-related cli flags
ok {test-number} - cli.parse({ "test", "--shard-index=0" }) for: {?}
# Parsing sharding-related cli flags
@@ -3487,6 +3224,40 @@ ok {test-number} - trim(StringRef(leading_whitespace)) == StringRef(no_whitespac
ok {test-number} - trim(StringRef(trailing_whitespace)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
# Trim strings
ok {test-number} - trim(StringRef(whitespace_at_both_ends)) == StringRef(no_whitespace) for: There is no extra whitespace here == There is no extra whitespace here
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, RangeEquals( c_array ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, UnorderedRangeEquals( c_array ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_3, !RangeEquals( array_int_4 ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_3, !UnorderedRangeEquals( array_int_4 ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - with 1 message: 'ContainerIsRandomAccess( array_int_a ) != ContainerIsRandomAccess( list_char_a )'
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, RangeEquals( list_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - array_int_a, UnorderedRangeEquals( list_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, RangeEquals( vector_char_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, UnorderedRangeEquals( vector_char_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, !RangeEquals( vector_char_b ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_int_a, !UnorderedRangeEquals( vector_char_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - a, !RangeEquals( b ) for: { 1, 2, 3 } not elements are { 3, 2, 1 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - a, UnorderedRangeEquals( b ) for: { 1, 2, 3 } unordered elements are { 3, 2, 1 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_a, RangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+# Type conversions of RangeEquals and similar
+ok {test-number} - vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough ) for: { 1, 2, 3 } unordered elements are { 2, 3, 4 }
# Unexpected exceptions can be translated
not ok {test-number} - unexpected exception with message: '3.14'
# Upcasting special member functions
@@ -3697,6 +3468,70 @@ ok {test-number} - mocked.m_derefed[2] for: true
ok {test-number} - !(mocked.m_derefed[3]) for: !false
# Usage of NoneTrue range matcher
ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of RangeEquals range matcher
+ok {test-number} - empty_vector, RangeEquals( empty_vector ) for: { } elements are { }
+# Usage of RangeEquals range matcher
+ok {test-number} - empty_vector, !RangeEquals( non_empty_vector ) for: { } not elements are { 1 }
+# Usage of RangeEquals range matcher
+ok {test-number} - non_empty_vector, !RangeEquals( empty_vector ) for: { 1 } not elements are { }
+# Usage of RangeEquals range matcher
+ok {test-number} - non_empty_array, RangeEquals( non_empty_array ) for: { 1 } elements are { 1 }
+# Usage of RangeEquals range matcher
+ok {test-number} - array_a, RangeEquals( array_a ) for: { 1, 2, 3 } elements are { 1, 2, 3 }
+# Usage of RangeEquals range matcher
+ok {test-number} - array_a, !RangeEquals( array_b ) for: { 1, 2, 3 } not elements are { 2, 2, 3 }
+# Usage of RangeEquals range matcher
+ok {test-number} - array_a, !RangeEquals( array_c ) for: { 1, 2, 3 } not elements are { 1, 2, 2 }
+# Usage of RangeEquals range matcher
+ok {test-number} - vector_a, !RangeEquals( vector_b ) for: { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - vector_a, RangeEquals( vector_a_plus_1, close_enough ) for: { 1, 2, 3 } elements are { 2, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - vector_a, !RangeEquals( vector_b, close_enough ) for: { 1, 2, 3 } not elements are { 3, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - needs_adl1, RangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
+# Usage of RangeEquals range matcher
+ok {test-number} - needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } ) for: { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1, !RangeEquals( arr ) for: { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[0] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[1] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[2] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - !(mocked1.m_derefed[3]) for: !false
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1, RangeEquals( arr ) for: { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[0] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[1] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[2] for: true
+# Usage of RangeEquals range matcher
+ok {test-number} - mocked1.m_derefed[3] for: true
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - empty_vector, UnorderedRangeEquals( empty_vector ) for: { } unordered elements are { }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - empty_vector, !UnorderedRangeEquals( non_empty_vector ) for: { } not unordered elements are { 1 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - non_empty_vector, !UnorderedRangeEquals( empty_vector ) for: { 1 } not unordered elements are { }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - non_empty_array, UnorderedRangeEquals( non_empty_array ) for: { 1 } unordered elements are { 1 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - array_a, UnorderedRangeEquals( array_a ) for: { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - array_a, !UnorderedRangeEquals( array_b ) for: { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b ) for: { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough ) for: { 1, 10, 20 } unordered elements are { 11, 21, 2 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - vector_a, !UnorderedRangeEquals( vector_b, close_enough ) for: { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
+# Usage of UnorderedRangeEquals range matcher
+ok {test-number} - needs_adl1, UnorderedRangeEquals( needs_adl2 ) for: { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
# Usage of the SizeIs range matcher
ok {test-number} - empty_vec, SizeIs(0) for: { } has size == 0
# Usage of the SizeIs range matcher
@@ -3873,6 +3708,10 @@ ok {test-number} - encode( "[\x01]" ) == "[\\x01]" for: "[\x01]" == "[\x01]"
ok {test-number} - encode( "[\x7F]" ) == "[\\x7F]" for: "[\x7F]" == "[\x7F]"
# XmlWriter writes boolean attributes as true/false
ok {test-number} - stream.str(), ContainsSubstring(R"(attr1="true")") && ContainsSubstring(R"(attr2="false")") for: "<?xml version="1.0" encoding="UTF-8"?> <Element1 attr1="true" attr2="false"/> " ( contains: "attr1="true"" and contains: "attr2="false"" )
+# a succeeding test can still be skipped
+ok {test-number} -
+# a succeeding test can still be skipped
+ok {test-number} - # SKIP
# analyse no analysis
ok {test-number} - analysis.mean.point.count() == 23 for: 23.0 == 23
# analyse no analysis
@@ -4043,6 +3882,12 @@ ok {test-number} - convertToBits( -0. ) == ( 1ULL << 63 ) for: 92233720368547758
ok {test-number} - convertToBits( std::numeric_limits<float>::denorm_min() ) == 1 for: 1 == 1
# convertToBits
ok {test-number} - convertToBits( std::numeric_limits<double>::denorm_min() ) == 1 for: 1 == 1
+# dynamic skipping works with generators
+ok {test-number} - # SKIP 'skipping because answer = 41'
+# dynamic skipping works with generators
+ok {test-number} -
+# dynamic skipping works with generators
+ok {test-number} - # SKIP 'skipping because answer = 43'
# empty tags are not allowed
ok {test-number} - Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
# erfc_inv
@@ -4061,6 +3906,22 @@ ok {test-number} -
ok {test-number} -
# even more nested SECTION tests
ok {test-number} -
+# failed assertions before SKIP cause test case to fail
+not ok {test-number} - 3 == 4
+# failed assertions before SKIP cause test case to fail
+ok {test-number} - # SKIP
+# failing for some generator values causes entire test case to fail
+not ok {test-number} - explicitly
+# failing for some generator values causes entire test case to fail
+ok {test-number} - # SKIP
+# failing for some generator values causes entire test case to fail
+not ok {test-number} - explicitly
+# failing for some generator values causes entire test case to fail
+ok {test-number} - # SKIP
+# failing in some unskipped sections causes entire test case to fail
+ok {test-number} - # SKIP
+# failing in some unskipped sections causes entire test case to fail
+not ok {test-number} - explicitly
# is_unary_function
ok {test-number} - with 1 message: 'Catch::Clara::Detail::is_unary_function<decltype(unary1)>::value'
# is_unary_function
@@ -4169,6 +4030,8 @@ ok {test-number} - a != b for: 1 != 2
ok {test-number} - b != a for: 2 != 1
# nested SECTION tests
ok {test-number} - a != b for: 1 != 2
+# nested sections can be skipped dynamically at runtime
+ok {test-number} - # SKIP
# non streamable - with conv. op
ok {test-number} - s == "7" for: "7" == "7"
# non-copyable objects
@@ -4333,12 +4196,20 @@ ok {test-number} - Timing.elapsed >= time for: 128 ns >= 100 ns
ok {test-number} - Timing.result == Timing.iterations + 17 for: 145 == 145
# run_for_at_least, int
ok {test-number} - Timing.iterations >= time.count() for: 128 >= 100
+# sections can be skipped dynamically at runtime
+ok {test-number} -
+# sections can be skipped dynamically at runtime
+ok {test-number} - # SKIP
+# sections can be skipped dynamically at runtime
+ok {test-number} -
# send a single char to INFO
not ok {test-number} - false with 1 message: '3'
# sends information to INFO
not ok {test-number} - false with 2 messages: 'hi' and 'i := 7'
# shortened hide tags are split apart
ok {test-number} - testcase.tags, VectorContains( Tag( "magic-tag" ) ) && VectorContains( Tag( "."_catch_sr ) ) for: { {?}, {?} } ( Contains: {?} and Contains: {?} )
+# skipped tests can optionally provide a reason
+ok {test-number} - # SKIP 'skipping because answer = 43'
# splitString
ok {test-number} - splitStringRef("", ','), Equals(std::vector<StringRef>()) for: { } Equals: { }
# splitString
@@ -4421,6 +4292,8 @@ ok {test-number} - strlen(std::get<0>(data)) == static_cast<size_t>(std::get<1>(
ok {test-number} - testcase.tags.size() == 1 for: 1 == 1
# tags with dots in later positions are not parsed as hidden
ok {test-number} - testcase.tags[0].original == "magic.tag"_catch_sr for: magic.tag == magic.tag
+# tests can be skipped dynamically at runtime
+ok {test-number} - # SKIP
# thrown std::strings are translated
not ok {test-number} - unexpected exception with message: 'Why would you throw a std::string?'
# toString on const wchar_t const pointer returns the string contents
@@ -4593,5 +4466,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
ok {test-number} -
# xmlentitycheck
ok {test-number} -
-1..2299
+1..2237
diff --git a/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.approved.txt
index 526f00a90f1b93d419920afb5d450bf9e675e8fc..a298633a16618590108f292f8d14a428e1ba47b6 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.approved.txt
@@ -18,7 +18,7 @@
##teamcity[testStarted name='#1455 - INFO and WARN can start with a linebreak']
##teamcity[testFinished name='#1455 - INFO and WARN can start with a linebreak' duration="{duration}"]
##teamcity[testStarted name='#1514: stderr/stdout is not captured in tests aborted by an exception']
-Tricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
+##teamcity[testFailed name='#1514: stderr/stdout is not captured in tests aborted by an exception' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
##teamcity[testStdOut name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='This would not be caught previously|n']
##teamcity[testStdErr name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='Nor would this|n']
##teamcity[testFinished name='#1514: stderr/stdout is not captured in tests aborted by an exception' duration="{duration}"]
@@ -52,30 +52,33 @@ Tricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - double' duration="{duration}"]
##teamcity[testStarted name='#2152 - ULP checks between differently signed values were wrong - float']
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - float' duration="{duration}"]
+##teamcity[testStarted name='#2615 - Throwing in constructor generator fails test case but does not abort']
+##teamcity[testIgnored name='#2615 - Throwing in constructor generator fails test case but does not abort' message='Generators.tests.cpp:<line number>|n...............................................................................|n|nGenerators.tests.cpp:<line number>|nunexpected exception with message:|n "failure to init"- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='#2615 - Throwing in constructor generator fails test case but does not abort' duration="{duration}"]
##teamcity[testStarted name='#748 - captures with unexpected exceptions']
-Exception.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"- failure ignore as test marked as |'ok to fail|'|n']
-Exception.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"|n REQUIRE_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|noutside assertions|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|ninside REQUIRE_NOTHROW|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"|n REQUIRE_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='#748 - captures with unexpected exceptions' duration="{duration}"]
##teamcity[testStarted name='#809']
##teamcity[testFinished name='#809' duration="{duration}"]
##teamcity[testStarted name='#833']
##teamcity[testFinished name='#833' duration="{duration}"]
##teamcity[testStarted name='#835 -- errno should not be touched by Catch2']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( f() == 0 )|nwith expansion:|n 1 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='#835 -- errno should not be touched by Catch2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( f() == 0 )|nwith expansion:|n 1 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='#835 -- errno should not be touched by Catch2' duration="{duration}"]
##teamcity[testStarted name='#872']
##teamcity[testFinished name='#872' duration="{duration}"]
##teamcity[testStarted name='#961 -- Dynamically created sections should all be reported']
##teamcity[testFinished name='#961 -- Dynamically created sections should all be reported' duration="{duration}"]
##teamcity[testStarted name='|'Not|' checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( false != false )|nwith expansion:|n false != false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( true != true )|nwith expansion:|n true != true|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !true )|nwith expansion:|n false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( true )|nwith expansion:|n !true|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !trueValue )|nwith expansion:|n false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( trueValue )|nwith expansion:|n !true|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !(1 == 1) )|nwith expansion:|n false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nwith expansion:|n !(1 == 1)|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( false != false )|nwith expansion:|n false != false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( true != true )|nwith expansion:|n true != true|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !true )|nwith expansion:|n false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( true )|nwith expansion:|n !true|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !trueValue )|nwith expansion:|n false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( trueValue )|nwith expansion:|n !true|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !(1 == 1) )|nwith expansion:|n false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nwith expansion:|n !(1 == 1)|n']
##teamcity[testFinished name='|'Not|' checks that should fail' duration="{duration}"]
##teamcity[testStarted name='|'Not|' checks that should succeed']
##teamcity[testFinished name='|'Not|' checks that should succeed' duration="{duration}"]
@@ -84,21 +87,21 @@ Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nw
##teamcity[testStarted name='3x3x3 ints']
##teamcity[testFinished name='3x3x3 ints' duration="{duration}"]
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that fails']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( s == "world" )|nwith expansion:|n "hello" == "world"|n']
+##teamcity[testFailed name='A METHOD_AS_TEST_CASE based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( s == "world" )|nwith expansion:|n "hello" == "world"|n']
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that fails' duration="{duration}"]
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that succeeds']
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that succeeds' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>' duration="{duration}"]
@@ -109,16 +112,16 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>' duration="{duration}"]
@@ -129,13 +132,13 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0 == 2|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0 == 2|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0f == 2|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0f == 2|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1 == 2|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1 == 2|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double' duration="{duration}"]
@@ -144,13 +147,13 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<Te
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 1 == 0|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 3 == 0|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 3 == 0|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 6 == 0|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 6 == 0|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1' duration="{duration}"]
@@ -159,7 +162,7 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::va
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6' duration="{duration}"]
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that fails']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith expansion:|n 1 == 2|n']
+##teamcity[testFailed name='A TEST_CASE_METHOD based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith expansion:|n 1 == 2|n']
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that fails' duration="{duration}"]
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that succeeds']
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that succeeds' duration="{duration}"]
@@ -182,11 +185,11 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith ex
##teamcity[testStarted name='A comparison that uses literals instead of the normal constructor']
##teamcity[testFinished name='A comparison that uses literals instead of the normal constructor' duration="{duration}"]
##teamcity[testStarted name='A couple of nested sections followed by a failure']
-Misc.tests.cpp:<line number>|nexplicit failure with message:|n "to infinity and beyond"']
+##teamcity[testFailed name='A couple of nested sections followed by a failure' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure with message:|n "to infinity and beyond"']
##teamcity[testFinished name='A couple of nested sections followed by a failure' duration="{duration}"]
##teamcity[testStarted name='A failing expression with a non streamable type is still captured']
-Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( &o1 == &o2 )|nwith expansion:|n 0x<hex digits> == 0x<hex digits>|n']
-Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith expansion:|n {?} == {?}|n']
+##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexpression failed|n CHECK( &o1 == &o2 )|nwith expansion:|n 0x<hex digits> == 0x<hex digits>|n']
+##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith expansion:|n {?} == {?}|n']
##teamcity[testFinished name='A failing expression with a non streamable type is still captured' duration="{duration}"]
##teamcity[testStarted name='Absolute margin']
##teamcity[testFinished name='Absolute margin' duration="{duration}"]
@@ -195,7 +198,7 @@ Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith exp
##teamcity[testStarted name='An expression with side-effects should only be evaluated once']
##teamcity[testFinished name='An expression with side-effects should only be evaluated once' duration="{duration}"]
##teamcity[testStarted name='An unchecked exception reports the line of the last assertion']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"|n {Unknown expression after the reported line}|nwith expansion:|n {Unknown expression after the reported line}|n']
+##teamcity[testFailed name='An unchecked exception reports the line of the last assertion' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"|n {Unknown expression after the reported line}|nwith expansion:|n {Unknown expression after the reported line}|n']
##teamcity[testFinished name='An unchecked exception reports the line of the last assertion' duration="{duration}"]
##teamcity[testStarted name='Anonymous test case 1']
##teamcity[testFinished name='Anonymous test case 1' duration="{duration}"]
@@ -276,33 +279,34 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpe
##teamcity[testStarted name='Composed matchers shortcircuit']
##teamcity[testFinished name='Composed matchers shortcircuit' duration="{duration}"]
##teamcity[testStarted name='Contains string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "not there" (case insensitive)|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "STRING"|n']
+##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "not there" (case insensitive)|n']
+##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "STRING"|n']
##teamcity[testFinished name='Contains string matcher' duration="{duration}"]
##teamcity[testStarted name='Copy and then generate a range']
##teamcity[testFinished name='Copy and then generate a range' duration="{duration}"]
##teamcity[testStarted name='Cout stream properly declares it writes to stdout']
##teamcity[testFinished name='Cout stream properly declares it writes to stdout' duration="{duration}"]
##teamcity[testStarted name='Custom exceptions can be translated when testing for nothrow']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_NOTHROW( throwCustom() )|nwith expansion:|n throwCustom()|n']
+##teamcity[testFailed name='Custom exceptions can be translated when testing for nothrow' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_NOTHROW( throwCustom() )|nwith expansion:|n throwCustom()|n']
##teamcity[testFinished name='Custom exceptions can be translated when testing for nothrow' duration="{duration}"]
##teamcity[testStarted name='Custom exceptions can be translated when testing for throwing as something else']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_THROWS_AS( throwCustom(), std::exception )|nwith expansion:|n throwCustom(), std::exception|n']
+##teamcity[testFailed name='Custom exceptions can be translated when testing for throwing as something else' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_THROWS_AS( throwCustom(), std::exception )|nwith expansion:|n throwCustom(), std::exception|n']
##teamcity[testFinished name='Custom exceptions can be translated when testing for throwing as something else' duration="{duration}"]
##teamcity[testStarted name='Custom std-exceptions can be custom translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom std exception"']
+##teamcity[testFailed name='Custom std-exceptions can be custom translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom std exception"']
##teamcity[testFinished name='Custom std-exceptions can be custom translated' duration="{duration}"]
##teamcity[testStarted name='Default scale is invisible to comparison']
##teamcity[testFinished name='Default scale is invisible to comparison' duration="{duration}"]
##teamcity[testStarted name='Directly creating an EnumInfo']
##teamcity[testFinished name='Directly creating an EnumInfo' duration="{duration}"]
+##teamcity[testStarted name='Empty generators can SKIP in constructor']
+##teamcity[testIgnored name='Empty generators can SKIP in constructor' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "This generator is empty"']
+##teamcity[testFinished name='Empty generators can SKIP in constructor' duration="{duration}"]
##teamcity[testStarted name='Empty stream name opens cout stream']
##teamcity[testFinished name='Empty stream name opens cout stream' duration="{duration}"]
-##teamcity[testStarted name='Empty tag is not allowed']
-##teamcity[testFinished name='Empty tag is not allowed' duration="{duration}"]
##teamcity[testStarted name='EndsWith string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "Substring"|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
+##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "Substring"|n']
+##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
##teamcity[testFinished name='EndsWith string matcher' duration="{duration}"]
##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
##teamcity[testFinished name='Enums can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
@@ -311,60 +315,64 @@ Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringFor
##teamcity[testStarted name='Epsilon only applies to Approx|'s value']
##teamcity[testFinished name='Epsilon only applies to Approx|'s value' duration="{duration}"]
##teamcity[testStarted name='Equality checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 6 )|nwith expansion:|n 7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 8 )|nwith expansion:|n 7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 0 )|nwith expansion:|n 7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n 9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n 9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n 9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n 9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n 3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "goodbye" )|nwith expansion:|n "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hell" )|nwith expansion:|n "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hello1" )|nwith expansion:|n "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() == 6 )|nwith expansion:|n 5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( x == Approx( 1.301 ) )|nwith expansion:|n 1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 6 )|nwith expansion:|n 7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 8 )|nwith expansion:|n 7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 0 )|nwith expansion:|n 7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n 9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n 9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n 9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n 9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n 3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "goodbye" )|nwith expansion:|n "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hell" )|nwith expansion:|n "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hello1" )|nwith expansion:|n "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() == 6 )|nwith expansion:|n 5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( x == Approx( 1.301 ) )|nwith expansion:|n 1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Equality checks that should fail' duration="{duration}"]
##teamcity[testStarted name='Equality checks that should succeed']
##teamcity[testFinished name='Equality checks that should succeed' duration="{duration}"]
##teamcity[testStarted name='Equals']
##teamcity[testFinished name='Equals' duration="{duration}"]
##teamcity[testStarted name='Equals string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "this string contains |'ABC|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "this string contains |'ABC|' as a substring"|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "something else" (case insensitive)|n']
+##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "this string contains |'ABC|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "this string contains |'ABC|' as a substring"|n']
+##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "something else" (case insensitive)|n']
##teamcity[testFinished name='Equals string matcher' duration="{duration}"]
##teamcity[testStarted name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified']
##teamcity[testFinished name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified' duration="{duration}"]
##teamcity[testStarted name='Exception matchers that fail']
-Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
+##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nNo exception|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nType mismatch|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nContents are wrong|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
+##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
##teamcity[testFinished name='Exception matchers that fail' duration="{duration}"]
##teamcity[testStarted name='Exception matchers that succeed']
##teamcity[testFinished name='Exception matchers that succeed' duration="{duration}"]
+##teamcity[testStarted name='Exception message can be matched']
+##teamcity[testFinished name='Exception message can be matched' duration="{duration}"]
##teamcity[testStarted name='Exception messages can be tested for']
##teamcity[testFinished name='Exception messages can be tested for' duration="{duration}"]
##teamcity[testStarted name='Exceptions matchers']
##teamcity[testFinished name='Exceptions matchers' duration="{duration}"]
##teamcity[testStarted name='Expected exceptions that don|'t throw or unexpected exceptions fail the test']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_THROWS_AS( thisThrows(), std::string )|nwith expansion:|n thisThrows(), std::string|n']
-Exception.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )|nwith expansion:|n thisDoesntThrow(), std::domain_error|n']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n']
+##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_THROWS_AS( thisThrows(), std::string )|nwith expansion:|n thisThrows(), std::string|n']
+##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )|nwith expansion:|n thisDoesntThrow(), std::domain_error|n']
+##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n']
##teamcity[testFinished name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' duration="{duration}"]
##teamcity[testStarted name='FAIL aborts the test']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
+##teamcity[testFailed name='FAIL aborts the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
##teamcity[testFinished name='FAIL aborts the test' duration="{duration}"]
##teamcity[testStarted name='FAIL does not require an argument']
-Message.tests.cpp:<line number>|nexplicit failure']
+##teamcity[testFailed name='FAIL does not require an argument' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure']
##teamcity[testFinished name='FAIL does not require an argument' duration="{duration}"]
##teamcity[testStarted name='FAIL_CHECK does not abort the test']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
+##teamcity[testFailed name='FAIL_CHECK does not abort the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
##teamcity[testFinished name='FAIL_CHECK does not abort the test' duration="{duration}"]
##teamcity[testStarted name='Factorials are computed']
##teamcity[testFinished name='Factorials are computed' duration="{duration}"]
+##teamcity[testStarted name='Filter generator throws exception for empty generator']
+##teamcity[testFinished name='Filter generator throws exception for empty generator' duration="{duration}"]
##teamcity[testStarted name='Floating point matchers: double']
##teamcity[testFinished name='Floating point matchers: double' duration="{duration}"]
##teamcity[testStarted name='Floating point matchers: float']
@@ -388,21 +396,21 @@ Message.tests.cpp:<line number>|nexplicit failure with message:|n "This is a fa
##teamcity[testStarted name='INFO and WARN do not abort tests']
##teamcity[testFinished name='INFO and WARN do not abort tests' duration="{duration}"]
##teamcity[testStarted name='INFO gets logged on failure']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message should be logged"|n "so should this"|n REQUIRE( a == 1 )|nwith expansion:|n 2 == 1|n']
+##teamcity[testFailed name='INFO gets logged on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message should be logged"|n "so should this"|n REQUIRE( a == 1 )|nwith expansion:|n 2 == 1|n']
##teamcity[testFinished name='INFO gets logged on failure' duration="{duration}"]
##teamcity[testStarted name='INFO gets logged on failure, even if captured before successful assertions']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n CHECK( a == 1 )|nwith expansion:|n 2 == 1|n']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n "and this, but later"|n CHECK( a == 0 )|nwith expansion:|n 2 == 0|n']
+##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n CHECK( a == 1 )|nwith expansion:|n 2 == 1|n']
+##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n "and this, but later"|n CHECK( a == 0 )|nwith expansion:|n 2 == 0|n']
##teamcity[testFinished name='INFO gets logged on failure, even if captured before successful assertions' duration="{duration}"]
##teamcity[testStarted name='INFO is reset for each loop']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "current counter 10"|n "i := 10"|n REQUIRE( i < 10 )|nwith expansion:|n 10 < 10|n']
+##teamcity[testFailed name='INFO is reset for each loop' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "current counter 10"|n "i := 10"|n REQUIRE( i < 10 )|nwith expansion:|n 10 < 10|n']
##teamcity[testFinished name='INFO is reset for each loop' duration="{duration}"]
##teamcity[testStarted name='Inequality checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven != 7 )|nwith expansion:|n 7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n 9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n 3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello != "hello" )|nwith expansion:|n "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() != 5 )|nwith expansion:|n 5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven != 7 )|nwith expansion:|n 7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n 9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n 3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello != "hello" )|nwith expansion:|n "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() != 5 )|nwith expansion:|n 5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Inequality checks that should fail' duration="{duration}"]
##teamcity[testStarted name='Inequality checks that should succeed']
##teamcity[testFinished name='Inequality checks that should succeed' duration="{duration}"]
@@ -419,21 +427,21 @@ Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.si
##teamcity[testStarted name='Matchers can be composed with both && and ||||']
##teamcity[testFinished name='Matchers can be composed with both && and ||||' duration="{duration}"]
##teamcity[testStarted name='Matchers can be composed with both && and |||| - failing']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) |||| ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )|n']
+##teamcity[testFailed name='Matchers can be composed with both && and |||| - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) |||| ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )|n']
##teamcity[testFinished name='Matchers can be composed with both && and |||| - failing' duration="{duration}"]
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator']
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator' duration="{duration}"]
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator - failing']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" not contains: "substring"|n']
+##teamcity[testFailed name='Matchers can be negated (Not) with the ! operator - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" not contains: "substring"|n']
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator - failing' duration="{duration}"]
##teamcity[testStarted name='Mayfail test case with nested sections']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Mayfail test case with nested sections' duration="{duration}"]
##teamcity[testStarted name='Mismatching exception messages failing the test']
-Exception.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thisThrows(), "should fail" )|nwith expansion:|n "expected exception" equals: "should fail"|n']
+##teamcity[testFailed name='Mismatching exception messages failing the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thisThrows(), "should fail" )|nwith expansion:|n "expected exception" equals: "should fail"|n']
##teamcity[testFinished name='Mismatching exception messages failing the test' duration="{duration}"]
##teamcity[testStarted name='Multireporter calls reporters and listeners in correct order']
##teamcity[testFinished name='Multireporter calls reporters and listeners in correct order' duration="{duration}"]
@@ -444,45 +452,45 @@ Exception.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thi
##teamcity[testStarted name='Nice descriptive name']
##teamcity[testFinished name='Nice descriptive name' duration="{duration}"]
##teamcity[testStarted name='Non-std exceptions can be translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception"']
+##teamcity[testFailed name='Non-std exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception"']
##teamcity[testFinished name='Non-std exceptions can be translated' duration="{duration}"]
##teamcity[testStarted name='Objects that evaluated in boolean contexts can be checked']
##teamcity[testFinished name='Objects that evaluated in boolean contexts can be checked' duration="{duration}"]
##teamcity[testStarted name='Optionally static assertions']
##teamcity[testFinished name='Optionally static assertions' duration="{duration}"]
##teamcity[testStarted name='Ordering comparison checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 7 )|nwith expansion:|n 7 > 7|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 7 )|nwith expansion:|n 7 < 7|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 8 )|nwith expansion:|n 7 > 8|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 6 )|nwith expansion:|n 7 < 6|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 0 )|nwith expansion:|n 7 < 0|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < -1 )|nwith expansion:|n 7 < -1|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven >= 8 )|nwith expansion:|n 7 >= 8|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven <= 6 )|nwith expansion:|n 7 <= 6|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n 9.1f < 9|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n 9.1f > 10|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n 9.1f > 9.2|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hello" )|nwith expansion:|n "hello" > "hello"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hello" )|nwith expansion:|n "hello" < "hello"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hellp" )|nwith expansion:|n "hello" > "hellp"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "z" )|nwith expansion:|n "hello" > "z"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hellm" )|nwith expansion:|n "hello" < "hellm"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "a" )|nwith expansion:|n "hello" < "a"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello >= "z" )|nwith expansion:|n "hello" >= "z"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello <= "a" )|nwith expansion:|n "hello" <= "a"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 7 )|nwith expansion:|n 7 > 7|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 7 )|nwith expansion:|n 7 < 7|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 8 )|nwith expansion:|n 7 > 8|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 6 )|nwith expansion:|n 7 < 6|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 0 )|nwith expansion:|n 7 < 0|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < -1 )|nwith expansion:|n 7 < -1|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven >= 8 )|nwith expansion:|n 7 >= 8|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven <= 6 )|nwith expansion:|n 7 <= 6|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n 9.1f < 9|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n 9.1f > 10|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n 9.1f > 9.2|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hello" )|nwith expansion:|n "hello" > "hello"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hello" )|nwith expansion:|n "hello" < "hello"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hellp" )|nwith expansion:|n "hello" > "hellp"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "z" )|nwith expansion:|n "hello" > "z"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hellm" )|nwith expansion:|n "hello" < "hellm"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "a" )|nwith expansion:|n "hello" < "a"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello >= "z" )|nwith expansion:|n "hello" >= "z"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello <= "a" )|nwith expansion:|n "hello" <= "a"|n']
##teamcity[testFinished name='Ordering comparison checks that should fail' duration="{duration}"]
##teamcity[testStarted name='Ordering comparison checks that should succeed']
##teamcity[testFinished name='Ordering comparison checks that should succeed' duration="{duration}"]
##teamcity[testStarted name='Our PCG implementation provides expected results for known seeds']
##teamcity[testFinished name='Our PCG implementation provides expected results for known seeds' duration="{duration}"]
##teamcity[testStarted name='Output from all sections is reported']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section one"']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section two"']
+##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|none|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section one"']
+##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|ntwo|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section two"']
##teamcity[testFinished name='Output from all sections is reported' duration="{duration}"]
##teamcity[testStarted name='Overloaded comma or address-of operators are not used']
##teamcity[testFinished name='Overloaded comma or address-of operators are not used' duration="{duration}"]
-##teamcity[testStarted name='Parse test names and tags']
-##teamcity[testFinished name='Parse test names and tags' duration="{duration}"]
+##teamcity[testStarted name='Parse uints']
+##teamcity[testFinished name='Parse uints' duration="{duration}"]
##teamcity[testStarted name='Parsed tags are matched case insensitive']
##teamcity[testFinished name='Parsed tags are matched case insensitive' duration="{duration}"]
##teamcity[testStarted name='Parsing sharding-related cli flags']
@@ -512,12 +520,12 @@ Message.tests.cpp:<line number>|nexplicit failure with message:|n "Message from
##teamcity[testStarted name='Range type with sentinel']
##teamcity[testFinished name='Range type with sentinel' duration="{duration}"]
##teamcity[testStarted name='Reconstruction should be based on stringification: #914']
-Decomposition.tests.cpp:<line number>|nexpression failed|n CHECK( truthy(false) )|nwith expansion:|n Hey, its truthy!|n']
+##teamcity[testFailed name='Reconstruction should be based on stringification: #914' message='Decomposition.tests.cpp:<line number>|n...............................................................................|n|nDecomposition.tests.cpp:<line number>|nexpression failed|n CHECK( truthy(false) )|nwith expansion:|n Hey, its truthy!|n']
##teamcity[testFinished name='Reconstruction should be based on stringification: #914' duration="{duration}"]
##teamcity[testStarted name='Regex string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this STRING contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this STRING contains |'abc|' as a substring" case sensitively|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "contains |'abc|' as a substring" case sensitively|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this string contains |'abc|' as a" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this string contains |'abc|' as a" case sensitively|n']
+##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this STRING contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this STRING contains |'abc|' as a substring" case sensitively|n']
+##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "contains |'abc|' as a substring" case sensitively|n']
+##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this string contains |'abc|' as a" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this string contains |'abc|' as a" case sensitively|n']
##teamcity[testFinished name='Regex string matcher' duration="{duration}"]
##teamcity[testStarted name='Registering reporter with |'::|' in name fails']
##teamcity[testFinished name='Registering reporter with |'::|' in name fails' duration="{duration}"]
@@ -549,8 +557,8 @@ Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringFor
##teamcity[testStdOut name='Standard output from all sections is reported' out='Message from section one|nMessage from section two|n']
##teamcity[testFinished name='Standard output from all sections is reported' duration="{duration}"]
##teamcity[testStarted name='StartsWith string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "This String"|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "string" (case insensitive)|n']
+##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "This String"|n']
+##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "string" (case insensitive)|n']
##teamcity[testFinished name='StartsWith string matcher' duration="{duration}"]
##teamcity[testStarted name='Static arrays are convertible to string']
##teamcity[testFinished name='Static arrays are convertible to string' duration="{duration}"]
@@ -573,7 +581,7 @@ Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringFor
##teamcity[testStarted name='Stringifying std::chrono::time_point<system_clock>']
##teamcity[testFinished name='Stringifying std::chrono::time_point<system_clock>' duration="{duration}"]
##teamcity[testStarted name='Tabs and newlines show in output']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expansion:|n "if ($b == 10) {|n $a = 20;|n}"|n==|n"if ($b == 10) {|n $a = 20;|n}|n"|n']
+##teamcity[testFailed name='Tabs and newlines show in output' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expansion:|n "if ($b == 10) {|n $a = 20;|n}"|n==|n"if ($b == 10) {|n $a = 20;|n}|n"|n']
##teamcity[testFinished name='Tabs and newlines show in output' duration="{duration}"]
##teamcity[testStarted name='Tag alias can be registered against tag patterns']
##teamcity[testFinished name='Tag alias can be registered against tag patterns' duration="{duration}"]
@@ -626,10 +634,10 @@ Misc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expan
##teamcity[testStarted name='Testing checked-if']
##teamcity[testFinished name='Testing checked-if' duration="{duration}"]
##teamcity[testStarted name='Testing checked-if 2']
-Misc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Testing checked-if 2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Testing checked-if 2' duration="{duration}"]
##teamcity[testStarted name='Testing checked-if 3']
-Misc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Testing checked-if 3' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Testing checked-if 3' duration="{duration}"]
##teamcity[testStarted name='The NO_FAIL macro reports a failure but does not fail the test']
##teamcity[testFinished name='The NO_FAIL macro reports a failure but does not fail the test' duration="{duration}"]
@@ -638,14 +646,16 @@ Misc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as
##teamcity[testStarted name='This test |'should|' fail but doesn|'t']
##teamcity[testFinished name='This test |'should|' fail but doesn|'t' duration="{duration}"]
##teamcity[testStarted name='Thrown string literals are translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "For some reason someone is throwing a string literal!"']
+##teamcity[testFailed name='Thrown string literals are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "For some reason someone is throwing a string literal!"']
##teamcity[testFinished name='Thrown string literals are translated' duration="{duration}"]
##teamcity[testStarted name='Tracker']
##teamcity[testFinished name='Tracker' duration="{duration}"]
##teamcity[testStarted name='Trim strings']
##teamcity[testFinished name='Trim strings' duration="{duration}"]
+##teamcity[testStarted name='Type conversions of RangeEquals and similar']
+##teamcity[testFinished name='Type conversions of RangeEquals and similar' duration="{duration}"]
##teamcity[testStarted name='Unexpected exceptions can be translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"']
+##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"']
##teamcity[testFinished name='Unexpected exceptions can be translated' duration="{duration}"]
##teamcity[testStarted name='Upcasting special member functions']
##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
@@ -661,6 +671,10 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"'
##teamcity[testFinished name='Usage of NoneMatch range matcher' duration="{duration}"]
##teamcity[testStarted name='Usage of NoneTrue range matcher']
##teamcity[testFinished name='Usage of NoneTrue range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of RangeEquals range matcher']
+##teamcity[testFinished name='Usage of RangeEquals range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of UnorderedRangeEquals range matcher']
+##teamcity[testFinished name='Usage of UnorderedRangeEquals range matcher' duration="{duration}"]
##teamcity[testStarted name='Usage of the SizeIs range matcher']
##teamcity[testFinished name='Usage of the SizeIs range matcher' duration="{duration}"]
##teamcity[testStarted name='Use a custom approx']
@@ -670,41 +684,41 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"'
##teamcity[testStarted name='Vector Approx matcher']
##teamcity[testFinished name='Vector Approx matcher' duration="{duration}"]
##teamcity[testStarted name='Vector Approx matcher -- failing']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Approx( t1 ) )|nwith expansion:|n { } is approx: { 1.0, 2.0 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v1, Approx( v2 ) )|nwith expansion:|n { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }|n']
+##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nEmpty and non empty vectors are not approx equal|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Approx( t1 ) )|nwith expansion:|n { } is approx: { 1.0, 2.0 }|n']
+##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nJust different vectors|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v1, Approx( v2 ) )|nwith expansion:|n { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }|n']
##teamcity[testFinished name='Vector Approx matcher -- failing' duration="{duration}"]
##teamcity[testStarted name='Vector matchers']
##teamcity[testFinished name='Vector matchers' duration="{duration}"]
##teamcity[testStarted name='Vector matchers that fail']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, VectorContains( -1 ) )|nwith expansion:|n { 1, 2, 3 } Contains: -1|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, VectorContains( 1 ) )|nwith expansion:|n { } Contains: 1|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Contains( v ) )|nwith expansion:|n { } Contains: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Contains( v2 ) )|nwith expansion:|n { 1, 2, 3 } Contains: { 1, 2, 4 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( v2 ) )|nwith expansion:|n { 1, 2, 3 } Equals: { 1, 2 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v2, Equals( v ) )|nwith expansion:|n { 1, 2 } Equals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Equals( v ) )|nwith expansion:|n { } Equals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( empty ) )|nwith expansion:|n { 1, 2, 3 } Equals: { }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, UnorderedEquals( empty ) )|nwith expansion:|n { 1, 2, 3 } UnorderedEquals: { }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, UnorderedEquals( v ) )|nwith expansion:|n { } UnorderedEquals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 1, 3 } UnorderedEquals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 3, 1 } UnorderedEquals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (element)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, VectorContains( -1 ) )|nwith expansion:|n { 1, 2, 3 } Contains: -1|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, VectorContains( 1 ) )|nwith expansion:|n { } Contains: 1|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (vector)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Contains( v ) )|nwith expansion:|n { } Contains: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Contains( v2 ) )|nwith expansion:|n { 1, 2, 3 } Contains: { 1, 2, 4 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( v2 ) )|nwith expansion:|n { 1, 2, 3 } Equals: { 1, 2 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v2, Equals( v ) )|nwith expansion:|n { 1, 2 } Equals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Equals( v ) )|nwith expansion:|n { } Equals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( empty ) )|nwith expansion:|n { 1, 2, 3 } Equals: { }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nUnorderedEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, UnorderedEquals( empty ) )|nwith expansion:|n { 1, 2, 3 } UnorderedEquals: { }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, UnorderedEquals( v ) )|nwith expansion:|n { } UnorderedEquals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 1, 3 } UnorderedEquals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 3, 1 } UnorderedEquals: { 1, 2, 3 }|n']
##teamcity[testFinished name='Vector matchers that fail' duration="{duration}"]
##teamcity[testStarted name='When checked exceptions are thrown they can be expected or unexpected']
##teamcity[testFinished name='When checked exceptions are thrown they can be expected or unexpected' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown directly they are always failures']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
+##teamcity[testFailed name='When unchecked exceptions are thrown directly they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
##teamcity[testFinished name='When unchecked exceptions are thrown directly they are always failures' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown during a CHECK the test should continue']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
+##teamcity[testFailed name='When unchecked exceptions are thrown during a CHECK the test should continue' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
##teamcity[testFinished name='When unchecked exceptions are thrown during a CHECK the test should continue' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n REQUIRE( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
+##teamcity[testFailed name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n REQUIRE( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
##teamcity[testFinished name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown from functions they are always failures']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
+##teamcity[testFailed name='When unchecked exceptions are thrown from functions they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
##teamcity[testFinished name='When unchecked exceptions are thrown from functions they are always failures' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown from sections they are always failures']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
+##teamcity[testFailed name='When unchecked exceptions are thrown from sections they are always failures' message='-------------------------------------------------------------------------------|nsection name|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
##teamcity[testFinished name='When unchecked exceptions are thrown from sections they are always failures' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown, but caught, they do not affect the test']
##teamcity[testFinished name='When unchecked exceptions are thrown, but caught, they do not affect the test' duration="{duration}"]
@@ -720,6 +734,9 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpe
##teamcity[testFinished name='XmlEncode' duration="{duration}"]
##teamcity[testStarted name='XmlWriter writes boolean attributes as true/false']
##teamcity[testFinished name='XmlWriter writes boolean attributes as true/false' duration="{duration}"]
+##teamcity[testStarted name='a succeeding test can still be skipped']
+##teamcity[testIgnored name='a succeeding test can still be skipped' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='a succeeding test can still be skipped' duration="{duration}"]
##teamcity[testStarted name='analyse no analysis']
##teamcity[testFinished name='analyse no analysis' duration="{duration}"]
##teamcity[testStarted name='array<int, N> -> toString']
@@ -731,12 +748,12 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpe
##teamcity[testStarted name='checkedElse']
##teamcity[testFinished name='checkedElse' duration="{duration}"]
##teamcity[testStarted name='checkedElse, failing']
-Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedElse( false ) )|nwith expansion:|n false|n']
+##teamcity[testFailed name='checkedElse, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedElse( false ) )|nwith expansion:|n false|n']
##teamcity[testFinished name='checkedElse, failing' duration="{duration}"]
##teamcity[testStarted name='checkedIf']
##teamcity[testFinished name='checkedIf' duration="{duration}"]
##teamcity[testStarted name='checkedIf, failing']
-Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false ) )|nwith expansion:|n false|n']
+##teamcity[testFailed name='checkedIf, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false ) )|nwith expansion:|n false|n']
##teamcity[testFinished name='checkedIf, failing' duration="{duration}"]
##teamcity[testStarted name='classify_outliers']
##teamcity[testFinished name='classify_outliers' duration="{duration}"]
@@ -746,6 +763,10 @@ Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false
##teamcity[testFinished name='comparisons between int variables' duration="{duration}"]
##teamcity[testStarted name='convertToBits']
##teamcity[testFinished name='convertToBits' duration="{duration}"]
+##teamcity[testStarted name='dynamic skipping works with generators']
+##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 41"']
+##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
+##teamcity[testFinished name='dynamic skipping works with generators' duration="{duration}"]
##teamcity[testStarted name='empty tags are not allowed']
##teamcity[testFinished name='empty tags are not allowed' duration="{duration}"]
##teamcity[testStarted name='erfc_inv']
@@ -754,6 +775,20 @@ Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false
##teamcity[testFinished name='estimate_clock_resolution' duration="{duration}"]
##teamcity[testStarted name='even more nested SECTION tests']
##teamcity[testFinished name='even more nested SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='failed assertions before SKIP cause test case to fail']
+##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexpression failed|n CHECK( 3 == 4 )|nwith expansion:|n 3 == 4|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='failed assertions before SKIP cause test case to fail' duration="{duration}"]
+##teamcity[testStarted name='failing for some generator values causes entire test case to fail']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='failing for some generator values causes entire test case to fail' duration="{duration}"]
+##teamcity[testStarted name='failing in some unskipped sections causes entire test case to fail']
+##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nnot skipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='failing in some unskipped sections causes entire test case to fail' duration="{duration}"]
##teamcity[testStarted name='first tag']
##teamcity[testFinished name='first tag' duration="{duration}"]
##teamcity[testStarted name='has printf']
@@ -762,10 +797,10 @@ loose text artifact
##teamcity[testStarted name='is_unary_function']
##teamcity[testFinished name='is_unary_function' duration="{duration}"]
##teamcity[testStarted name='just failure']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "Previous info should not be seen"']
+##teamcity[testFailed name='just failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Previous info should not be seen"']
##teamcity[testFinished name='just failure' duration="{duration}"]
##teamcity[testStarted name='just failure after unscoped info']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "previous unscoped info SHOULD not be seen"']
+##teamcity[testFailed name='just failure after unscoped info' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "previous unscoped info SHOULD not be seen"']
##teamcity[testFinished name='just failure after unscoped info' duration="{duration}"]
##teamcity[testStarted name='just info']
##teamcity[testFinished name='just info' duration="{duration}"]
@@ -774,16 +809,16 @@ Message.tests.cpp:<line number>|nexplicit failure with message:|n "previous uns
##teamcity[testStarted name='long long']
##teamcity[testFinished name='long long' duration="{duration}"]
##teamcity[testStarted name='looped SECTION tests']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 0 > 1|n']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 1 > 1|n']
+##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 0|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 0 > 1|n']
+##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 1|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 1 > 1|n']
##teamcity[testFinished name='looped SECTION tests' duration="{duration}"]
##teamcity[testStarted name='looped tests']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[0|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[1|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[3|] (3) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[4|] (5) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[6|] (13) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[7|] (21) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[0|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[1|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[3|] (3) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[4|] (5) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[6|] (13) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[7|] (21) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
##teamcity[testFinished name='looped tests' duration="{duration}"]
##teamcity[testStarted name='makeStream recognizes %debug stream name']
##teamcity[testFinished name='makeStream recognizes %debug stream name' duration="{duration}"]
@@ -796,10 +831,14 @@ Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib
##teamcity[testStarted name='mix info, unscoped info and warning']
##teamcity[testFinished name='mix info, unscoped info and warning' duration="{duration}"]
##teamcity[testStarted name='more nested SECTION tests']
-Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expansion:|n 1 == 2|n']
+##teamcity[testFailed name='more nested SECTION tests' message='-------------------------------------------------------------------------------|ndoesn|'t equal|nequal|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expansion:|n 1 == 2|n']
##teamcity[testFinished name='more nested SECTION tests' duration="{duration}"]
##teamcity[testStarted name='nested SECTION tests']
##teamcity[testFinished name='nested SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='nested sections can be skipped dynamically at runtime']
+##teamcity[testIgnored name='nested sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nB|nB2|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testStdOut name='nested sections can be skipped dynamically at runtime' out='a!|nb1!|n!|n']
+##teamcity[testFinished name='nested sections can be skipped dynamically at runtime' duration="{duration}"]
##teamcity[testStarted name='non streamable - with conv. op']
##teamcity[testFinished name='non streamable - with conv. op' duration="{duration}"]
##teamcity[testStarted name='non-copyable objects']
@@ -811,7 +850,7 @@ Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expan
##teamcity[testStarted name='not allowed']
##teamcity[testFinished name='not allowed' duration="{duration}"]
##teamcity[testStarted name='not prints unscoped info from previous failures']
-Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='not prints unscoped info from previous failures' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='not prints unscoped info from previous failures' duration="{duration}"]
##teamcity[testStarted name='null strings']
##teamcity[testFinished name='null strings' duration="{duration}"]
@@ -826,10 +865,10 @@ Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD
##teamcity[testStarted name='print unscoped info if passing unscoped info is printed']
##teamcity[testFinished name='print unscoped info if passing unscoped info is printed' duration="{duration}"]
##teamcity[testStarted name='prints unscoped info on failure']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this SHOULD be seen"|n "this SHOULD also be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='prints unscoped info on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this SHOULD be seen"|n "this SHOULD also be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='prints unscoped info on failure' duration="{duration}"]
##teamcity[testStarted name='prints unscoped info only for the first assertion']
-Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen only ONCE"|n CHECK( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='prints unscoped info only for the first assertion' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen only ONCE"|n CHECK( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='prints unscoped info only for the first assertion' duration="{duration}"]
##teamcity[testStarted name='random SECTION tests']
##teamcity[testFinished name='random SECTION tests' duration="{duration}"]
@@ -845,19 +884,25 @@ Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD
##teamcity[testFinished name='run_for_at_least, int' duration="{duration}"]
##teamcity[testStarted name='second tag']
##teamcity[testFinished name='second tag' duration="{duration}"]
+##teamcity[testStarted name='sections can be skipped dynamically at runtime']
+##teamcity[testIgnored name='sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='sections can be skipped dynamically at runtime' duration="{duration}"]
##teamcity[testStarted name='send a single char to INFO']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "3"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='send a single char to INFO' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "3"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='send a single char to INFO' duration="{duration}"]
##teamcity[testStarted name='sends information to INFO']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "hi"|n "i := 7"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='sends information to INFO' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "hi"|n "i := 7"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='sends information to INFO' duration="{duration}"]
##teamcity[testStarted name='shortened hide tags are split apart']
##teamcity[testFinished name='shortened hide tags are split apart' duration="{duration}"]
+##teamcity[testStarted name='skipped tests can optionally provide a reason']
+##teamcity[testIgnored name='skipped tests can optionally provide a reason' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
+##teamcity[testFinished name='skipped tests can optionally provide a reason' duration="{duration}"]
##teamcity[testStarted name='splitString']
##teamcity[testFinished name='splitString' duration="{duration}"]
##teamcity[testStarted name='stacks unscoped info in loops']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 1 to 3..."|n "1"|n "2"|n "3"|n CHECK( false )|nwith expansion:|n false|n']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to 6..."|n "4"|n "5"|n "6"|n CHECK( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "Count 1 to 3..."|n "1"|n "2"|n "3"|n CHECK( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to 6..."|n "4"|n "5"|n "6"|n CHECK( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='stacks unscoped info in loops' duration="{duration}"]
##teamcity[testStarted name='startsWith']
##teamcity[testFinished name='startsWith' duration="{duration}"]
@@ -897,8 +942,11 @@ Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to
##teamcity[testFinished name='tables' duration="{duration}"]
##teamcity[testStarted name='tags with dots in later positions are not parsed as hidden']
##teamcity[testFinished name='tags with dots in later positions are not parsed as hidden' duration="{duration}"]
+##teamcity[testStarted name='tests can be skipped dynamically at runtime']
+##teamcity[testIgnored name='tests can be skipped dynamically at runtime' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='tests can be skipped dynamically at runtime' duration="{duration}"]
##teamcity[testStarted name='thrown std::strings are translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "Why would you throw a std::string?"']
+##teamcity[testFailed name='thrown std::strings are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "Why would you throw a std::string?"']
##teamcity[testFinished name='thrown std::strings are translated' duration="{duration}"]
##teamcity[testStarted name='toString on const wchar_t const pointer returns the string contents']
##teamcity[testFinished name='toString on const wchar_t const pointer returns the string contents' duration="{duration}"]
diff --git a/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
index 2b7914464be15e51fa64e35f56d695364bd3e772..861d64715b55a33c980cc2d135d069dcf9ad5459 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
@@ -18,7 +18,7 @@
##teamcity[testStarted name='#1455 - INFO and WARN can start with a linebreak']
##teamcity[testFinished name='#1455 - INFO and WARN can start with a linebreak' duration="{duration}"]
##teamcity[testStarted name='#1514: stderr/stdout is not captured in tests aborted by an exception']
-Tricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
+##teamcity[testFailed name='#1514: stderr/stdout is not captured in tests aborted by an exception' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
##teamcity[testStdOut name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='This would not be caught previously|n']
##teamcity[testStdErr name='#1514: stderr/stdout is not captured in tests aborted by an exception' out='Nor would this|n']
##teamcity[testFinished name='#1514: stderr/stdout is not captured in tests aborted by an exception' duration="{duration}"]
@@ -52,30 +52,33 @@ Tricky.tests.cpp:<line number>|nexplicit failure with message:|n "1514"']
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - double' duration="{duration}"]
##teamcity[testStarted name='#2152 - ULP checks between differently signed values were wrong - float']
##teamcity[testFinished name='#2152 - ULP checks between differently signed values were wrong - float' duration="{duration}"]
+##teamcity[testStarted name='#2615 - Throwing in constructor generator fails test case but does not abort']
+##teamcity[testIgnored name='#2615 - Throwing in constructor generator fails test case but does not abort' message='Generators.tests.cpp:<line number>|n...............................................................................|n|nGenerators.tests.cpp:<line number>|nunexpected exception with message:|n "failure to init"- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='#2615 - Throwing in constructor generator fails test case but does not abort' duration="{duration}"]
##teamcity[testStarted name='#748 - captures with unexpected exceptions']
-Exception.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"- failure ignore as test marked as |'ok to fail|'|n']
-Exception.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"|n REQUIRE_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|noutside assertions|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='#748 - captures with unexpected exceptions' message='-------------------------------------------------------------------------------|ninside REQUIRE_NOTHROW|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with messages:|n "answer := 42"|n "expected exception"|n REQUIRE_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='#748 - captures with unexpected exceptions' duration="{duration}"]
##teamcity[testStarted name='#809']
##teamcity[testFinished name='#809' duration="{duration}"]
##teamcity[testStarted name='#833']
##teamcity[testFinished name='#833' duration="{duration}"]
##teamcity[testStarted name='#835 -- errno should not be touched by Catch2']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( f() == 0 )|nwith expansion:|n 1 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='#835 -- errno should not be touched by Catch2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( f() == 0 )|nwith expansion:|n 1 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='#835 -- errno should not be touched by Catch2' duration="{duration}"]
##teamcity[testStarted name='#872']
##teamcity[testFinished name='#872' duration="{duration}"]
##teamcity[testStarted name='#961 -- Dynamically created sections should all be reported']
##teamcity[testFinished name='#961 -- Dynamically created sections should all be reported' duration="{duration}"]
##teamcity[testStarted name='|'Not|' checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( false != false )|nwith expansion:|n false != false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( true != true )|nwith expansion:|n true != true|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !true )|nwith expansion:|n false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( true )|nwith expansion:|n !true|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !trueValue )|nwith expansion:|n false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( trueValue )|nwith expansion:|n !true|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !(1 == 1) )|nwith expansion:|n false|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nwith expansion:|n !(1 == 1)|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( false != false )|nwith expansion:|n false != false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( true != true )|nwith expansion:|n true != true|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !true )|nwith expansion:|n false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( true )|nwith expansion:|n !true|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !trueValue )|nwith expansion:|n false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( trueValue )|nwith expansion:|n !true|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( !(1 == 1) )|nwith expansion:|n false|n']
+##teamcity[testFailed name='|'Not|' checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nwith expansion:|n !(1 == 1)|n']
##teamcity[testFinished name='|'Not|' checks that should fail' duration="{duration}"]
##teamcity[testStarted name='|'Not|' checks that should succeed']
##teamcity[testFinished name='|'Not|' checks that should succeed' duration="{duration}"]
@@ -84,21 +87,21 @@ Condition.tests.cpp:<line number>|nexpression failed|n CHECK_FALSE( 1 == 1 )|nw
##teamcity[testStarted name='3x3x3 ints']
##teamcity[testFinished name='3x3x3 ints' duration="{duration}"]
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that fails']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( s == "world" )|nwith expansion:|n "hello" == "world"|n']
+##teamcity[testFailed name='A METHOD_AS_TEST_CASE based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( s == "world" )|nwith expansion:|n "hello" == "world"|n']
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that fails' duration="{duration}"]
##teamcity[testStarted name='A METHOD_AS_TEST_CASE based test run that succeeds']
##teamcity[testFinished name='A METHOD_AS_TEST_CASE based test run that succeeds' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>::m_a.size() == 1 )|nwith expansion:|n 0 == 1|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>' duration="{duration}"]
@@ -109,16 +112,16 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 6 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
+##teamcity[testFailed name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<TestType>{}.m_a.size() < 2 )|nwith expansion:|n 2 < 2|n']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>' duration="{duration}"]
@@ -129,13 +132,13 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture_2<
##teamcity[testStarted name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>']
##teamcity[testFinished name='A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0 == 2|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0 == 2|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - double' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0f == 2|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1.0f == 2|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - float' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1 == 2|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<TestType>::m_a == 2 )|nwith expansion:|n 1 == 2|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that fails - int' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double' duration="{duration}"]
@@ -144,13 +147,13 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Template_Fixture<Te
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 1 == 0|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 3 == 0|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 3 == 0|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 6 == 0|n']
+##teamcity[testFailed name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::value == 0 )|nwith expansion:|n 6 == 0|n']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6' duration="{duration}"]
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1' duration="{duration}"]
@@ -159,7 +162,7 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( Nttp_Fixture<V>::va
##teamcity[testStarted name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6']
##teamcity[testFinished name='A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6' duration="{duration}"]
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that fails']
-Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith expansion:|n 1 == 2|n']
+##teamcity[testFailed name='A TEST_CASE_METHOD based test run that fails' message='Class.tests.cpp:<line number>|n...............................................................................|n|nClass.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith expansion:|n 1 == 2|n']
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that fails' duration="{duration}"]
##teamcity[testStarted name='A TEST_CASE_METHOD based test run that succeeds']
##teamcity[testFinished name='A TEST_CASE_METHOD based test run that succeeds' duration="{duration}"]
@@ -182,11 +185,11 @@ Class.tests.cpp:<line number>|nexpression failed|n REQUIRE( m_a == 2 )|nwith ex
##teamcity[testStarted name='A comparison that uses literals instead of the normal constructor']
##teamcity[testFinished name='A comparison that uses literals instead of the normal constructor' duration="{duration}"]
##teamcity[testStarted name='A couple of nested sections followed by a failure']
-Misc.tests.cpp:<line number>|nexplicit failure with message:|n "to infinity and beyond"']
+##teamcity[testFailed name='A couple of nested sections followed by a failure' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure with message:|n "to infinity and beyond"']
##teamcity[testFinished name='A couple of nested sections followed by a failure' duration="{duration}"]
##teamcity[testStarted name='A failing expression with a non streamable type is still captured']
-Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( &o1 == &o2 )|nwith expansion:|n 0x<hex digits> == 0x<hex digits>|n']
-Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith expansion:|n {?} == {?}|n']
+##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|n...............................................................................|n|nTricky.tests.cpp:<line number>|nexpression failed|n CHECK( &o1 == &o2 )|nwith expansion:|n 0x<hex digits> == 0x<hex digits>|n']
+##teamcity[testFailed name='A failing expression with a non streamable type is still captured' message='Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith expansion:|n {?} == {?}|n']
##teamcity[testFinished name='A failing expression with a non streamable type is still captured' duration="{duration}"]
##teamcity[testStarted name='Absolute margin']
##teamcity[testFinished name='Absolute margin' duration="{duration}"]
@@ -195,7 +198,7 @@ Tricky.tests.cpp:<line number>|nexpression failed|n CHECK( o1 == o2 )|nwith exp
##teamcity[testStarted name='An expression with side-effects should only be evaluated once']
##teamcity[testFinished name='An expression with side-effects should only be evaluated once' duration="{duration}"]
##teamcity[testStarted name='An unchecked exception reports the line of the last assertion']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"|n {Unknown expression after the reported line}|nwith expansion:|n {Unknown expression after the reported line}|n']
+##teamcity[testFailed name='An unchecked exception reports the line of the last assertion' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"|n {Unknown expression after the reported line}|nwith expansion:|n {Unknown expression after the reported line}|n']
##teamcity[testFinished name='An unchecked exception reports the line of the last assertion' duration="{duration}"]
##teamcity[testStarted name='Anonymous test case 1']
##teamcity[testFinished name='Anonymous test case 1' duration="{duration}"]
@@ -276,33 +279,34 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpe
##teamcity[testStarted name='Composed matchers shortcircuit']
##teamcity[testFinished name='Composed matchers shortcircuit' duration="{duration}"]
##teamcity[testStarted name='Contains string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "not there" (case insensitive)|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "STRING"|n']
+##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "not there", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "not there" (case insensitive)|n']
+##teamcity[testFailed name='Contains string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ContainsSubstring( "STRING" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" contains: "STRING"|n']
##teamcity[testFinished name='Contains string matcher' duration="{duration}"]
##teamcity[testStarted name='Copy and then generate a range']
##teamcity[testFinished name='Copy and then generate a range' duration="{duration}"]
##teamcity[testStarted name='Cout stream properly declares it writes to stdout']
##teamcity[testFinished name='Cout stream properly declares it writes to stdout' duration="{duration}"]
##teamcity[testStarted name='Custom exceptions can be translated when testing for nothrow']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_NOTHROW( throwCustom() )|nwith expansion:|n throwCustom()|n']
+##teamcity[testFailed name='Custom exceptions can be translated when testing for nothrow' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_NOTHROW( throwCustom() )|nwith expansion:|n throwCustom()|n']
##teamcity[testFinished name='Custom exceptions can be translated when testing for nothrow' duration="{duration}"]
##teamcity[testStarted name='Custom exceptions can be translated when testing for throwing as something else']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_THROWS_AS( throwCustom(), std::exception )|nwith expansion:|n throwCustom(), std::exception|n']
+##teamcity[testFailed name='Custom exceptions can be translated when testing for throwing as something else' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception - not std"|n REQUIRE_THROWS_AS( throwCustom(), std::exception )|nwith expansion:|n throwCustom(), std::exception|n']
##teamcity[testFinished name='Custom exceptions can be translated when testing for throwing as something else' duration="{duration}"]
##teamcity[testStarted name='Custom std-exceptions can be custom translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom std exception"']
+##teamcity[testFailed name='Custom std-exceptions can be custom translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom std exception"']
##teamcity[testFinished name='Custom std-exceptions can be custom translated' duration="{duration}"]
##teamcity[testStarted name='Default scale is invisible to comparison']
##teamcity[testFinished name='Default scale is invisible to comparison' duration="{duration}"]
##teamcity[testStarted name='Directly creating an EnumInfo']
##teamcity[testFinished name='Directly creating an EnumInfo' duration="{duration}"]
+##teamcity[testStarted name='Empty generators can SKIP in constructor']
+##teamcity[testIgnored name='Empty generators can SKIP in constructor' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "This generator is empty"']
+##teamcity[testFinished name='Empty generators can SKIP in constructor' duration="{duration}"]
##teamcity[testStarted name='Empty stream name opens cout stream']
##teamcity[testFinished name='Empty stream name opens cout stream' duration="{duration}"]
-##teamcity[testStarted name='Empty tag is not allowed']
-##teamcity[testFinished name='Empty tag is not allowed' duration="{duration}"]
##teamcity[testStarted name='EndsWith string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "Substring"|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
+##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "Substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "Substring"|n']
+##teamcity[testFailed name='EndsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), EndsWith( "this", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ends with: "this" (case insensitive)|n']
##teamcity[testFinished name='EndsWith string matcher' duration="{duration}"]
##teamcity[testStarted name='Enums can quickly have stringification enabled using REGISTER_ENUM']
##teamcity[testFinished name='Enums can quickly have stringification enabled using REGISTER_ENUM' duration="{duration}"]
@@ -311,60 +315,64 @@ Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringFor
##teamcity[testStarted name='Epsilon only applies to Approx|'s value']
##teamcity[testFinished name='Epsilon only applies to Approx|'s value' duration="{duration}"]
##teamcity[testStarted name='Equality checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 6 )|nwith expansion:|n 7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 8 )|nwith expansion:|n 7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 0 )|nwith expansion:|n 7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n 9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n 9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n 9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n 9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n 3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "goodbye" )|nwith expansion:|n "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hell" )|nwith expansion:|n "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hello1" )|nwith expansion:|n "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() == 6 )|nwith expansion:|n 5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( x == Approx( 1.301 ) )|nwith expansion:|n 1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 6 )|nwith expansion:|n 7 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 8 )|nwith expansion:|n 7 == 8|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven == 0 )|nwith expansion:|n 7 == 0|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.11f ) )|nwith expansion:|n 9.1f == Approx( 9.1099996567 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 9.0f ) )|nwith expansion:|n 9.1f == Approx( 9.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 1 ) )|nwith expansion:|n 9.1f == Approx( 1.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one == Approx( 0 ) )|nwith expansion:|n 9.1f == Approx( 0.0 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi == Approx( 3.1415 ) )|nwith expansion:|n 3.1415926535 == Approx( 3.1415 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "goodbye" )|nwith expansion:|n "hello" == "goodbye"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hell" )|nwith expansion:|n "hello" == "hell"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello == "hello1" )|nwith expansion:|n "hello" == "hello1"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() == 6 )|nwith expansion:|n 5 == 6|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Equality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( x == Approx( 1.301 ) )|nwith expansion:|n 1.3 == Approx( 1.301 )|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Equality checks that should fail' duration="{duration}"]
##teamcity[testStarted name='Equality checks that should succeed']
##teamcity[testFinished name='Equality checks that should succeed' duration="{duration}"]
##teamcity[testStarted name='Equals']
##teamcity[testFinished name='Equals' duration="{duration}"]
##teamcity[testStarted name='Equals string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "this string contains |'ABC|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "this string contains |'ABC|' as a substring"|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "something else" (case insensitive)|n']
+##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "this string contains |'ABC|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "this string contains |'ABC|' as a substring"|n']
+##teamcity[testFailed name='Equals string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Equals( "something else", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" equals: "something else" (case insensitive)|n']
##teamcity[testFinished name='Equals string matcher' duration="{duration}"]
##teamcity[testStarted name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified']
##teamcity[testFinished name='Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified' duration="{duration}"]
##teamcity[testStarted name='Exception matchers that fail']
-Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
+##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nNo exception|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nno exception was thrown where one was expected|n REQUIRE_THROWS_MATCHES( doesNotThrow(), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nType mismatch|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n CHECK_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nunexpected exception with message:|n "Unknown exception"|n REQUIRE_THROWS_MATCHES( throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n throwsAsInt( 1 ), SpecialException, ExceptionMatcher{ 1 }|n']
+##teamcity[testFailed name='Exception matchers that fail' message='-------------------------------------------------------------------------------|nContents are wrong|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THROWS_MATCHES( throwsSpecialException( 3 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
+##teamcity[testFailed name='Exception matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_MATCHES( throwsSpecialException( 4 ), SpecialException, ExceptionMatcher{ 1 } )|nwith expansion:|n SpecialException::what special exception has value of 1|n']
##teamcity[testFinished name='Exception matchers that fail' duration="{duration}"]
##teamcity[testStarted name='Exception matchers that succeed']
##teamcity[testFinished name='Exception matchers that succeed' duration="{duration}"]
+##teamcity[testStarted name='Exception message can be matched']
+##teamcity[testFinished name='Exception message can be matched' duration="{duration}"]
##teamcity[testStarted name='Exception messages can be tested for']
##teamcity[testFinished name='Exception messages can be tested for' duration="{duration}"]
##teamcity[testStarted name='Exceptions matchers']
##teamcity[testFinished name='Exceptions matchers' duration="{duration}"]
##teamcity[testStarted name='Expected exceptions that don|'t throw or unexpected exceptions fail the test']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_THROWS_AS( thisThrows(), std::string )|nwith expansion:|n thisThrows(), std::string|n']
-Exception.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )|nwith expansion:|n thisDoesntThrow(), std::domain_error|n']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n']
+##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_THROWS_AS( thisThrows(), std::string )|nwith expansion:|n thisThrows(), std::string|n']
+##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nno exception was thrown where one was expected|n CHECK_THROWS_AS( thisDoesntThrow(), std::domain_error )|nwith expansion:|n thisDoesntThrow(), std::domain_error|n']
+##teamcity[testFailed name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' message='Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK_NOTHROW( thisThrows() )|nwith expansion:|n thisThrows()|n']
##teamcity[testFinished name='Expected exceptions that don|'t throw or unexpected exceptions fail the test' duration="{duration}"]
##teamcity[testStarted name='FAIL aborts the test']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
+##teamcity[testFailed name='FAIL aborts the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
##teamcity[testFinished name='FAIL aborts the test' duration="{duration}"]
##teamcity[testStarted name='FAIL does not require an argument']
-Message.tests.cpp:<line number>|nexplicit failure']
+##teamcity[testFailed name='FAIL does not require an argument' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure']
##teamcity[testFinished name='FAIL does not require an argument' duration="{duration}"]
##teamcity[testStarted name='FAIL_CHECK does not abort the test']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
+##teamcity[testFailed name='FAIL_CHECK does not abort the test' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "This is a failure"']
##teamcity[testFinished name='FAIL_CHECK does not abort the test' duration="{duration}"]
##teamcity[testStarted name='Factorials are computed']
##teamcity[testFinished name='Factorials are computed' duration="{duration}"]
+##teamcity[testStarted name='Filter generator throws exception for empty generator']
+##teamcity[testFinished name='Filter generator throws exception for empty generator' duration="{duration}"]
##teamcity[testStarted name='Floating point matchers: double']
##teamcity[testFinished name='Floating point matchers: double' duration="{duration}"]
##teamcity[testStarted name='Floating point matchers: float']
@@ -388,21 +396,21 @@ Message.tests.cpp:<line number>|nexplicit failure with message:|n "This is a fa
##teamcity[testStarted name='INFO and WARN do not abort tests']
##teamcity[testFinished name='INFO and WARN do not abort tests' duration="{duration}"]
##teamcity[testStarted name='INFO gets logged on failure']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message should be logged"|n "so should this"|n REQUIRE( a == 1 )|nwith expansion:|n 2 == 1|n']
+##teamcity[testFailed name='INFO gets logged on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message should be logged"|n "so should this"|n REQUIRE( a == 1 )|nwith expansion:|n 2 == 1|n']
##teamcity[testFinished name='INFO gets logged on failure' duration="{duration}"]
##teamcity[testStarted name='INFO gets logged on failure, even if captured before successful assertions']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n CHECK( a == 1 )|nwith expansion:|n 2 == 1|n']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n "and this, but later"|n CHECK( a == 0 )|nwith expansion:|n 2 == 0|n']
+##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n CHECK( a == 1 )|nwith expansion:|n 2 == 1|n']
+##teamcity[testFailed name='INFO gets logged on failure, even if captured before successful assertions' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "this message may be logged later"|n "this message should be logged"|n "and this, but later"|n CHECK( a == 0 )|nwith expansion:|n 2 == 0|n']
##teamcity[testFinished name='INFO gets logged on failure, even if captured before successful assertions' duration="{duration}"]
##teamcity[testStarted name='INFO is reset for each loop']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "current counter 10"|n "i := 10"|n REQUIRE( i < 10 )|nwith expansion:|n 10 < 10|n']
+##teamcity[testFailed name='INFO is reset for each loop' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "current counter 10"|n "i := 10"|n REQUIRE( i < 10 )|nwith expansion:|n 10 < 10|n']
##teamcity[testFinished name='INFO is reset for each loop' duration="{duration}"]
##teamcity[testStarted name='Inequality checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven != 7 )|nwith expansion:|n 7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n 9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n 3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello != "hello" )|nwith expansion:|n "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() != 5 )|nwith expansion:|n 5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven != 7 )|nwith expansion:|n 7 != 7|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one != Approx( 9.1f ) )|nwith expansion:|n 9.1f != Approx( 9.1000003815 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.double_pi != Approx( 3.1415926535 ) )|nwith expansion:|n 3.1415926535 != Approx( 3.1415926535 )|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello != "hello" )|nwith expansion:|n "hello" != "hello"|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Inequality checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.size() != 5 )|nwith expansion:|n 5 != 5|n- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Inequality checks that should fail' duration="{duration}"]
##teamcity[testStarted name='Inequality checks that should succeed']
##teamcity[testFinished name='Inequality checks that should succeed' duration="{duration}"]
@@ -419,21 +427,21 @@ Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello.si
##teamcity[testStarted name='Matchers can be composed with both && and ||||']
##teamcity[testFinished name='Matchers can be composed with both && and ||||' duration="{duration}"]
##teamcity[testStarted name='Matchers can be composed with both && and |||| - failing']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) |||| ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )|n']
+##teamcity[testFailed name='Matchers can be composed with both && and |||| - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), ( ContainsSubstring( "string" ) |||| ContainsSubstring( "different" ) ) && ContainsSubstring( "random" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )|n']
##teamcity[testFinished name='Matchers can be composed with both && and |||| - failing' duration="{duration}"]
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator']
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator' duration="{duration}"]
##teamcity[testStarted name='Matchers can be negated (Not) with the ! operator - failing']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" not contains: "substring"|n']
+##teamcity[testFailed name='Matchers can be negated (Not) with the ! operator - failing' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), !ContainsSubstring( "substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" not contains: "substring"|n']
##teamcity[testFinished name='Matchers can be negated (Not) with the ! operator - failing' duration="{duration}"]
##teamcity[testStarted name='Mayfail test case with nested sections']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
-Condition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nA|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n1|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Mayfail test case with nested sections' message='-------------------------------------------------------------------------------|nB|n2|n-------------------------------------------------------------------------------|nCondition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Mayfail test case with nested sections' duration="{duration}"]
##teamcity[testStarted name='Mismatching exception messages failing the test']
-Exception.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thisThrows(), "should fail" )|nwith expansion:|n "expected exception" equals: "should fail"|n']
+##teamcity[testFailed name='Mismatching exception messages failing the test' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thisThrows(), "should fail" )|nwith expansion:|n "expected exception" equals: "should fail"|n']
##teamcity[testFinished name='Mismatching exception messages failing the test' duration="{duration}"]
##teamcity[testStarted name='Multireporter calls reporters and listeners in correct order']
##teamcity[testFinished name='Multireporter calls reporters and listeners in correct order' duration="{duration}"]
@@ -444,45 +452,45 @@ Exception.tests.cpp:<line number>|nexpression failed|n REQUIRE_THROWS_WITH( thi
##teamcity[testStarted name='Nice descriptive name']
##teamcity[testFinished name='Nice descriptive name' duration="{duration}"]
##teamcity[testStarted name='Non-std exceptions can be translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception"']
+##teamcity[testFailed name='Non-std exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "custom exception"']
##teamcity[testFinished name='Non-std exceptions can be translated' duration="{duration}"]
##teamcity[testStarted name='Objects that evaluated in boolean contexts can be checked']
##teamcity[testFinished name='Objects that evaluated in boolean contexts can be checked' duration="{duration}"]
##teamcity[testStarted name='Optionally static assertions']
##teamcity[testFinished name='Optionally static assertions' duration="{duration}"]
##teamcity[testStarted name='Ordering comparison checks that should fail']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 7 )|nwith expansion:|n 7 > 7|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 7 )|nwith expansion:|n 7 < 7|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 8 )|nwith expansion:|n 7 > 8|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 6 )|nwith expansion:|n 7 < 6|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 0 )|nwith expansion:|n 7 < 0|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < -1 )|nwith expansion:|n 7 < -1|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven >= 8 )|nwith expansion:|n 7 >= 8|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven <= 6 )|nwith expansion:|n 7 <= 6|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n 9.1f < 9|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n 9.1f > 10|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n 9.1f > 9.2|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hello" )|nwith expansion:|n "hello" > "hello"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hello" )|nwith expansion:|n "hello" < "hello"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hellp" )|nwith expansion:|n "hello" > "hellp"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "z" )|nwith expansion:|n "hello" > "z"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hellm" )|nwith expansion:|n "hello" < "hellm"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "a" )|nwith expansion:|n "hello" < "a"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello >= "z" )|nwith expansion:|n "hello" >= "z"|n']
-Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello <= "a" )|nwith expansion:|n "hello" <= "a"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|n...............................................................................|n|nCondition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 7 )|nwith expansion:|n 7 > 7|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 7 )|nwith expansion:|n 7 < 7|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven > 8 )|nwith expansion:|n 7 > 8|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 6 )|nwith expansion:|n 7 < 6|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < 0 )|nwith expansion:|n 7 < 0|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven < -1 )|nwith expansion:|n 7 < -1|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven >= 8 )|nwith expansion:|n 7 >= 8|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.int_seven <= 6 )|nwith expansion:|n 7 <= 6|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one < 9 )|nwith expansion:|n 9.1f < 9|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 10 )|nwith expansion:|n 9.1f > 10|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.float_nine_point_one > 9.2 )|nwith expansion:|n 9.1f > 9.2|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hello" )|nwith expansion:|n "hello" > "hello"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hello" )|nwith expansion:|n "hello" < "hello"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "hellp" )|nwith expansion:|n "hello" > "hellp"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello > "z" )|nwith expansion:|n "hello" > "z"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "hellm" )|nwith expansion:|n "hello" < "hellm"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello < "a" )|nwith expansion:|n "hello" < "a"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello >= "z" )|nwith expansion:|n "hello" >= "z"|n']
+##teamcity[testFailed name='Ordering comparison checks that should fail' message='Condition.tests.cpp:<line number>|nexpression failed|n CHECK( data.str_hello <= "a" )|nwith expansion:|n "hello" <= "a"|n']
##teamcity[testFinished name='Ordering comparison checks that should fail' duration="{duration}"]
##teamcity[testStarted name='Ordering comparison checks that should succeed']
##teamcity[testFinished name='Ordering comparison checks that should succeed' duration="{duration}"]
##teamcity[testStarted name='Our PCG implementation provides expected results for known seeds']
##teamcity[testFinished name='Our PCG implementation provides expected results for known seeds' duration="{duration}"]
##teamcity[testStarted name='Output from all sections is reported']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section one"']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section two"']
+##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|none|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section one"']
+##teamcity[testFailed name='Output from all sections is reported' message='-------------------------------------------------------------------------------|ntwo|n-------------------------------------------------------------------------------|nMessage.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Message from section two"']
##teamcity[testFinished name='Output from all sections is reported' duration="{duration}"]
##teamcity[testStarted name='Overloaded comma or address-of operators are not used']
##teamcity[testFinished name='Overloaded comma or address-of operators are not used' duration="{duration}"]
-##teamcity[testStarted name='Parse test names and tags']
-##teamcity[testFinished name='Parse test names and tags' duration="{duration}"]
+##teamcity[testStarted name='Parse uints']
+##teamcity[testFinished name='Parse uints' duration="{duration}"]
##teamcity[testStarted name='Parsed tags are matched case insensitive']
##teamcity[testFinished name='Parsed tags are matched case insensitive' duration="{duration}"]
##teamcity[testStarted name='Parsing sharding-related cli flags']
@@ -512,12 +520,12 @@ Message.tests.cpp:<line number>|nexplicit failure with message:|n "Message from
##teamcity[testStarted name='Range type with sentinel']
##teamcity[testFinished name='Range type with sentinel' duration="{duration}"]
##teamcity[testStarted name='Reconstruction should be based on stringification: #914']
-Decomposition.tests.cpp:<line number>|nexpression failed|n CHECK( truthy(false) )|nwith expansion:|n Hey, its truthy!|n']
+##teamcity[testFailed name='Reconstruction should be based on stringification: #914' message='Decomposition.tests.cpp:<line number>|n...............................................................................|n|nDecomposition.tests.cpp:<line number>|nexpression failed|n CHECK( truthy(false) )|nwith expansion:|n Hey, its truthy!|n']
##teamcity[testFinished name='Reconstruction should be based on stringification: #914' duration="{duration}"]
##teamcity[testStarted name='Regex string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this STRING contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this STRING contains |'abc|' as a substring" case sensitively|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "contains |'abc|' as a substring" case sensitively|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this string contains |'abc|' as a" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this string contains |'abc|' as a" case sensitively|n']
+##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this STRING contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this STRING contains |'abc|' as a substring" case sensitively|n']
+##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "contains |'abc|' as a substring" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "contains |'abc|' as a substring" case sensitively|n']
+##teamcity[testFailed name='Regex string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), Matches( "this string contains |'abc|' as a" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" matches "this string contains |'abc|' as a" case sensitively|n']
##teamcity[testFinished name='Regex string matcher' duration="{duration}"]
##teamcity[testStarted name='Registering reporter with |'::|' in name fails']
##teamcity[testFinished name='Registering reporter with |'::|' in name fails' duration="{duration}"]
@@ -549,8 +557,8 @@ Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringFor
##teamcity[testStdOut name='Standard output from all sections is reported' out='Message from section one|nMessage from section two|n']
##teamcity[testFinished name='Standard output from all sections is reported' duration="{duration}"]
##teamcity[testStarted name='StartsWith string matcher']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "This String"|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "string" (case insensitive)|n']
+##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "This String" ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "This String"|n']
+##teamcity[testFailed name='StartsWith string matcher' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringForMatching(), StartsWith( "string", Catch::CaseSensitive::No ) )|nwith expansion:|n "this string contains |'abc|' as a substring" starts with: "string" (case insensitive)|n']
##teamcity[testFinished name='StartsWith string matcher' duration="{duration}"]
##teamcity[testStarted name='Static arrays are convertible to string']
##teamcity[testFinished name='Static arrays are convertible to string' duration="{duration}"]
@@ -573,7 +581,7 @@ Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( testStringFor
##teamcity[testStarted name='Stringifying std::chrono::time_point<system_clock>']
##teamcity[testFinished name='Stringifying std::chrono::time_point<system_clock>' duration="{duration}"]
##teamcity[testStarted name='Tabs and newlines show in output']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expansion:|n "if ($b == 10) {|n $a = 20;|n}"|n==|n"if ($b == 10) {|n $a = 20;|n}|n"|n']
+##teamcity[testFailed name='Tabs and newlines show in output' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expansion:|n "if ($b == 10) {|n $a = 20;|n}"|n==|n"if ($b == 10) {|n $a = 20;|n}|n"|n']
##teamcity[testFinished name='Tabs and newlines show in output' duration="{duration}"]
##teamcity[testStarted name='Tag alias can be registered against tag patterns']
##teamcity[testFinished name='Tag alias can be registered against tag patterns' duration="{duration}"]
@@ -626,10 +634,10 @@ Misc.tests.cpp:<line number>|nexpression failed|n CHECK( s1 == s2 )|nwith expan
##teamcity[testStarted name='Testing checked-if']
##teamcity[testFinished name='Testing checked-if' duration="{duration}"]
##teamcity[testStarted name='Testing checked-if 2']
-Misc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Testing checked-if 2' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Testing checked-if 2' duration="{duration}"]
##teamcity[testStarted name='Testing checked-if 3']
-Misc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='Testing checked-if 3' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
##teamcity[testFinished name='Testing checked-if 3' duration="{duration}"]
##teamcity[testStarted name='The NO_FAIL macro reports a failure but does not fail the test']
##teamcity[testFinished name='The NO_FAIL macro reports a failure but does not fail the test' duration="{duration}"]
@@ -638,14 +646,16 @@ Misc.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as
##teamcity[testStarted name='This test |'should|' fail but doesn|'t']
##teamcity[testFinished name='This test |'should|' fail but doesn|'t' duration="{duration}"]
##teamcity[testStarted name='Thrown string literals are translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "For some reason someone is throwing a string literal!"']
+##teamcity[testFailed name='Thrown string literals are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "For some reason someone is throwing a string literal!"']
##teamcity[testFinished name='Thrown string literals are translated' duration="{duration}"]
##teamcity[testStarted name='Tracker']
##teamcity[testFinished name='Tracker' duration="{duration}"]
##teamcity[testStarted name='Trim strings']
##teamcity[testFinished name='Trim strings' duration="{duration}"]
+##teamcity[testStarted name='Type conversions of RangeEquals and similar']
+##teamcity[testFinished name='Type conversions of RangeEquals and similar' duration="{duration}"]
##teamcity[testStarted name='Unexpected exceptions can be translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"']
+##teamcity[testFailed name='Unexpected exceptions can be translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"']
##teamcity[testFinished name='Unexpected exceptions can be translated' duration="{duration}"]
##teamcity[testStarted name='Upcasting special member functions']
##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
@@ -661,6 +671,10 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"'
##teamcity[testFinished name='Usage of NoneMatch range matcher' duration="{duration}"]
##teamcity[testStarted name='Usage of NoneTrue range matcher']
##teamcity[testFinished name='Usage of NoneTrue range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of RangeEquals range matcher']
+##teamcity[testFinished name='Usage of RangeEquals range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of UnorderedRangeEquals range matcher']
+##teamcity[testFinished name='Usage of UnorderedRangeEquals range matcher' duration="{duration}"]
##teamcity[testStarted name='Usage of the SizeIs range matcher']
##teamcity[testFinished name='Usage of the SizeIs range matcher' duration="{duration}"]
##teamcity[testStarted name='Use a custom approx']
@@ -670,41 +684,41 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "3.14"'
##teamcity[testStarted name='Vector Approx matcher']
##teamcity[testFinished name='Vector Approx matcher' duration="{duration}"]
##teamcity[testStarted name='Vector Approx matcher -- failing']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Approx( t1 ) )|nwith expansion:|n { } is approx: { 1.0, 2.0 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v1, Approx( v2 ) )|nwith expansion:|n { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }|n']
+##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nEmpty and non empty vectors are not approx equal|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Approx( t1 ) )|nwith expansion:|n { } is approx: { 1.0, 2.0 }|n']
+##teamcity[testFailed name='Vector Approx matcher -- failing' message='-------------------------------------------------------------------------------|nJust different vectors|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v1, Approx( v2 ) )|nwith expansion:|n { 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }|n']
##teamcity[testFinished name='Vector Approx matcher -- failing' duration="{duration}"]
##teamcity[testStarted name='Vector matchers']
##teamcity[testFinished name='Vector matchers' duration="{duration}"]
##teamcity[testStarted name='Vector matchers that fail']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, VectorContains( -1 ) )|nwith expansion:|n { 1, 2, 3 } Contains: -1|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, VectorContains( 1 ) )|nwith expansion:|n { } Contains: 1|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Contains( v ) )|nwith expansion:|n { } Contains: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Contains( v2 ) )|nwith expansion:|n { 1, 2, 3 } Contains: { 1, 2, 4 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( v2 ) )|nwith expansion:|n { 1, 2, 3 } Equals: { 1, 2 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v2, Equals( v ) )|nwith expansion:|n { 1, 2 } Equals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Equals( v ) )|nwith expansion:|n { } Equals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( empty ) )|nwith expansion:|n { 1, 2, 3 } Equals: { }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, UnorderedEquals( empty ) )|nwith expansion:|n { 1, 2, 3 } UnorderedEquals: { }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, UnorderedEquals( v ) )|nwith expansion:|n { } UnorderedEquals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 1, 3 } UnorderedEquals: { 1, 2, 3 }|n']
-Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 3, 1 } UnorderedEquals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (element)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, VectorContains( -1 ) )|nwith expansion:|n { 1, 2, 3 } Contains: -1|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, VectorContains( 1 ) )|nwith expansion:|n { } Contains: 1|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nContains (vector)|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Contains( v ) )|nwith expansion:|n { } Contains: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Contains( v2 ) )|nwith expansion:|n { 1, 2, 3 } Contains: { 1, 2, 4 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( v2 ) )|nwith expansion:|n { 1, 2, 3 } Equals: { 1, 2 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v2, Equals( v ) )|nwith expansion:|n { 1, 2 } Equals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, Equals( v ) )|nwith expansion:|n { } Equals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, Equals( empty ) )|nwith expansion:|n { 1, 2, 3 } Equals: { }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='-------------------------------------------------------------------------------|nUnorderedEquals|n-------------------------------------------------------------------------------|nMatchers.tests.cpp:<line number>|n...............................................................................|n|nMatchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( v, UnorderedEquals( empty ) )|nwith expansion:|n { 1, 2, 3 } UnorderedEquals: { }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( empty, UnorderedEquals( v ) )|nwith expansion:|n { } UnorderedEquals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 1, 3 } UnorderedEquals: { 1, 2, 3 }|n']
+##teamcity[testFailed name='Vector matchers that fail' message='Matchers.tests.cpp:<line number>|nexpression failed|n CHECK_THAT( permuted, UnorderedEquals( v ) )|nwith expansion:|n { 3, 1 } UnorderedEquals: { 1, 2, 3 }|n']
##teamcity[testFinished name='Vector matchers that fail' duration="{duration}"]
##teamcity[testStarted name='When checked exceptions are thrown they can be expected or unexpected']
##teamcity[testFinished name='When checked exceptions are thrown they can be expected or unexpected' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown directly they are always failures']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
+##teamcity[testFailed name='When unchecked exceptions are thrown directly they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
##teamcity[testFinished name='When unchecked exceptions are thrown directly they are always failures' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown during a CHECK the test should continue']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
+##teamcity[testFailed name='When unchecked exceptions are thrown during a CHECK the test should continue' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
##teamcity[testFinished name='When unchecked exceptions are thrown during a CHECK the test should continue' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n REQUIRE( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
+##teamcity[testFailed name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n REQUIRE( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
##teamcity[testFinished name='When unchecked exceptions are thrown during a REQUIRE the test should abort fail' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown from functions they are always failures']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
+##teamcity[testFailed name='When unchecked exceptions are thrown from functions they are always failures' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "expected exception"|n CHECK( thisThrows() == 0 )|nwith expansion:|n thisThrows() == 0|n']
##teamcity[testFinished name='When unchecked exceptions are thrown from functions they are always failures' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown from sections they are always failures']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
+##teamcity[testFailed name='When unchecked exceptions are thrown from sections they are always failures' message='-------------------------------------------------------------------------------|nsection name|n-------------------------------------------------------------------------------|nException.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "unexpected exception"']
##teamcity[testFinished name='When unchecked exceptions are thrown from sections they are always failures' duration="{duration}"]
##teamcity[testStarted name='When unchecked exceptions are thrown, but caught, they do not affect the test']
##teamcity[testFinished name='When unchecked exceptions are thrown, but caught, they do not affect the test' duration="{duration}"]
@@ -720,6 +734,9 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpe
##teamcity[testFinished name='XmlEncode' duration="{duration}"]
##teamcity[testStarted name='XmlWriter writes boolean attributes as true/false']
##teamcity[testFinished name='XmlWriter writes boolean attributes as true/false' duration="{duration}"]
+##teamcity[testStarted name='a succeeding test can still be skipped']
+##teamcity[testIgnored name='a succeeding test can still be skipped' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='a succeeding test can still be skipped' duration="{duration}"]
##teamcity[testStarted name='analyse no analysis']
##teamcity[testFinished name='analyse no analysis' duration="{duration}"]
##teamcity[testStarted name='array<int, N> -> toString']
@@ -731,12 +748,12 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n "unexpe
##teamcity[testStarted name='checkedElse']
##teamcity[testFinished name='checkedElse' duration="{duration}"]
##teamcity[testStarted name='checkedElse, failing']
-Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedElse( false ) )|nwith expansion:|n false|n']
+##teamcity[testFailed name='checkedElse, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedElse( false ) )|nwith expansion:|n false|n']
##teamcity[testFinished name='checkedElse, failing' duration="{duration}"]
##teamcity[testStarted name='checkedIf']
##teamcity[testFinished name='checkedIf' duration="{duration}"]
##teamcity[testStarted name='checkedIf, failing']
-Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false ) )|nwith expansion:|n false|n']
+##teamcity[testFailed name='checkedIf, failing' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false ) )|nwith expansion:|n false|n']
##teamcity[testFinished name='checkedIf, failing' duration="{duration}"]
##teamcity[testStarted name='classify_outliers']
##teamcity[testFinished name='classify_outliers' duration="{duration}"]
@@ -746,6 +763,10 @@ Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false
##teamcity[testFinished name='comparisons between int variables' duration="{duration}"]
##teamcity[testStarted name='convertToBits']
##teamcity[testFinished name='convertToBits' duration="{duration}"]
+##teamcity[testStarted name='dynamic skipping works with generators']
+##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 41"']
+##teamcity[testIgnored name='dynamic skipping works with generators' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
+##teamcity[testFinished name='dynamic skipping works with generators' duration="{duration}"]
##teamcity[testStarted name='empty tags are not allowed']
##teamcity[testFinished name='empty tags are not allowed' duration="{duration}"]
##teamcity[testStarted name='erfc_inv']
@@ -754,6 +775,20 @@ Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false
##teamcity[testFinished name='estimate_clock_resolution' duration="{duration}"]
##teamcity[testStarted name='even more nested SECTION tests']
##teamcity[testFinished name='even more nested SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='failed assertions before SKIP cause test case to fail']
+##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexpression failed|n CHECK( 3 == 4 )|nwith expansion:|n 3 == 4|n- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='failed assertions before SKIP cause test case to fail' message='Skip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='failed assertions before SKIP cause test case to fail' duration="{duration}"]
+##teamcity[testStarted name='failing for some generator values causes entire test case to fail']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testIgnored name='failing for some generator values causes entire test case to fail' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='failing for some generator values causes entire test case to fail' duration="{duration}"]
+##teamcity[testStarted name='failing in some unskipped sections causes entire test case to fail']
+##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testIgnored name='failing in some unskipped sections causes entire test case to fail' message='-------------------------------------------------------------------------------|nnot skipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit failure- failure ignore as test marked as |'ok to fail|'|n']
+##teamcity[testFinished name='failing in some unskipped sections causes entire test case to fail' duration="{duration}"]
##teamcity[testStarted name='first tag']
##teamcity[testFinished name='first tag' duration="{duration}"]
##teamcity[testStarted name='has printf']
@@ -761,10 +796,10 @@ Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( testCheckedIf( false
##teamcity[testStarted name='is_unary_function']
##teamcity[testFinished name='is_unary_function' duration="{duration}"]
##teamcity[testStarted name='just failure']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "Previous info should not be seen"']
+##teamcity[testFailed name='just failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "Previous info should not be seen"']
##teamcity[testFinished name='just failure' duration="{duration}"]
##teamcity[testStarted name='just failure after unscoped info']
-Message.tests.cpp:<line number>|nexplicit failure with message:|n "previous unscoped info SHOULD not be seen"']
+##teamcity[testFailed name='just failure after unscoped info' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexplicit failure with message:|n "previous unscoped info SHOULD not be seen"']
##teamcity[testFinished name='just failure after unscoped info' duration="{duration}"]
##teamcity[testStarted name='just info']
##teamcity[testFinished name='just info' duration="{duration}"]
@@ -773,16 +808,16 @@ Message.tests.cpp:<line number>|nexplicit failure with message:|n "previous uns
##teamcity[testStarted name='long long']
##teamcity[testFinished name='long long' duration="{duration}"]
##teamcity[testStarted name='looped SECTION tests']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 0 > 1|n']
-Misc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 1 > 1|n']
+##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 0|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 0 > 1|n']
+##teamcity[testFailed name='looped SECTION tests' message='-------------------------------------------------------------------------------|nb is currently: 1|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n CHECK( b > a )|nwith expansion:|n 1 > 1|n']
##teamcity[testFinished name='looped SECTION tests' duration="{duration}"]
##teamcity[testStarted name='looped tests']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[0|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[1|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[3|] (3) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[4|] (5) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[6|] (13) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[7|] (21) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[0|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[1|] (1) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[3|] (3) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[4|] (5) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[6|] (13) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
+##teamcity[testFailed name='looped tests' message='Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib|[7|] (21) is even"|n CHECK( ( fib|[i|] % 2 ) == 0 )|nwith expansion:|n 1 == 0|n']
##teamcity[testFinished name='looped tests' duration="{duration}"]
##teamcity[testStarted name='makeStream recognizes %debug stream name']
##teamcity[testFinished name='makeStream recognizes %debug stream name' duration="{duration}"]
@@ -795,10 +830,14 @@ Misc.tests.cpp:<line number>|nexpression failed with message:|n "Testing if fib
##teamcity[testStarted name='mix info, unscoped info and warning']
##teamcity[testFinished name='mix info, unscoped info and warning' duration="{duration}"]
##teamcity[testStarted name='more nested SECTION tests']
-Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expansion:|n 1 == 2|n']
+##teamcity[testFailed name='more nested SECTION tests' message='-------------------------------------------------------------------------------|ndoesn|'t equal|nequal|n-------------------------------------------------------------------------------|nMisc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expansion:|n 1 == 2|n']
##teamcity[testFinished name='more nested SECTION tests' duration="{duration}"]
##teamcity[testStarted name='nested SECTION tests']
##teamcity[testFinished name='nested SECTION tests' duration="{duration}"]
+##teamcity[testStarted name='nested sections can be skipped dynamically at runtime']
+##teamcity[testIgnored name='nested sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nB|nB2|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testStdOut name='nested sections can be skipped dynamically at runtime' out='a!|nb1!|n!|n']
+##teamcity[testFinished name='nested sections can be skipped dynamically at runtime' duration="{duration}"]
##teamcity[testStarted name='non streamable - with conv. op']
##teamcity[testFinished name='non streamable - with conv. op' duration="{duration}"]
##teamcity[testStarted name='non-copyable objects']
@@ -810,7 +849,7 @@ Misc.tests.cpp:<line number>|nexpression failed|n REQUIRE( a == b )|nwith expan
##teamcity[testStarted name='not allowed']
##teamcity[testFinished name='not allowed' duration="{duration}"]
##teamcity[testStarted name='not prints unscoped info from previous failures']
-Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='not prints unscoped info from previous failures' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='not prints unscoped info from previous failures' duration="{duration}"]
##teamcity[testStarted name='null strings']
##teamcity[testFinished name='null strings' duration="{duration}"]
@@ -825,10 +864,10 @@ Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD
##teamcity[testStarted name='print unscoped info if passing unscoped info is printed']
##teamcity[testFinished name='print unscoped info if passing unscoped info is printed' duration="{duration}"]
##teamcity[testStarted name='prints unscoped info on failure']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "this SHOULD be seen"|n "this SHOULD also be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='prints unscoped info on failure' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "this SHOULD be seen"|n "this SHOULD also be seen"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='prints unscoped info on failure' duration="{duration}"]
##teamcity[testStarted name='prints unscoped info only for the first assertion']
-Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen only ONCE"|n CHECK( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='prints unscoped info only for the first assertion' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD be seen only ONCE"|n CHECK( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='prints unscoped info only for the first assertion' duration="{duration}"]
##teamcity[testStarted name='random SECTION tests']
##teamcity[testFinished name='random SECTION tests' duration="{duration}"]
@@ -844,19 +883,25 @@ Message.tests.cpp:<line number>|nexpression failed with message:|n "this SHOULD
##teamcity[testFinished name='run_for_at_least, int' duration="{duration}"]
##teamcity[testStarted name='second tag']
##teamcity[testFinished name='second tag' duration="{duration}"]
+##teamcity[testStarted name='sections can be skipped dynamically at runtime']
+##teamcity[testIgnored name='sections can be skipped dynamically at runtime' message='-------------------------------------------------------------------------------|nskipped|n-------------------------------------------------------------------------------|nSkip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='sections can be skipped dynamically at runtime' duration="{duration}"]
##teamcity[testStarted name='send a single char to INFO']
-Misc.tests.cpp:<line number>|nexpression failed with message:|n "3"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='send a single char to INFO' message='Misc.tests.cpp:<line number>|n...............................................................................|n|nMisc.tests.cpp:<line number>|nexpression failed with message:|n "3"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='send a single char to INFO' duration="{duration}"]
##teamcity[testStarted name='sends information to INFO']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "hi"|n "i := 7"|n REQUIRE( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='sends information to INFO' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "hi"|n "i := 7"|n REQUIRE( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='sends information to INFO' duration="{duration}"]
##teamcity[testStarted name='shortened hide tags are split apart']
##teamcity[testFinished name='shortened hide tags are split apart' duration="{duration}"]
+##teamcity[testStarted name='skipped tests can optionally provide a reason']
+##teamcity[testIgnored name='skipped tests can optionally provide a reason' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip with message:|n "skipping because answer = 43"']
+##teamcity[testFinished name='skipped tests can optionally provide a reason' duration="{duration}"]
##teamcity[testStarted name='splitString']
##teamcity[testFinished name='splitString' duration="{duration}"]
##teamcity[testStarted name='stacks unscoped info in loops']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 1 to 3..."|n "1"|n "2"|n "3"|n CHECK( false )|nwith expansion:|n false|n']
-Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to 6..."|n "4"|n "5"|n "6"|n CHECK( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|n...............................................................................|n|nMessage.tests.cpp:<line number>|nexpression failed with messages:|n "Count 1 to 3..."|n "1"|n "2"|n "3"|n CHECK( false )|nwith expansion:|n false|n']
+##teamcity[testFailed name='stacks unscoped info in loops' message='Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to 6..."|n "4"|n "5"|n "6"|n CHECK( false )|nwith expansion:|n false|n']
##teamcity[testFinished name='stacks unscoped info in loops' duration="{duration}"]
##teamcity[testStarted name='startsWith']
##teamcity[testFinished name='startsWith' duration="{duration}"]
@@ -896,8 +941,11 @@ Message.tests.cpp:<line number>|nexpression failed with messages:|n "Count 4 to
##teamcity[testFinished name='tables' duration="{duration}"]
##teamcity[testStarted name='tags with dots in later positions are not parsed as hidden']
##teamcity[testFinished name='tags with dots in later positions are not parsed as hidden' duration="{duration}"]
+##teamcity[testStarted name='tests can be skipped dynamically at runtime']
+##teamcity[testIgnored name='tests can be skipped dynamically at runtime' message='Skip.tests.cpp:<line number>|n...............................................................................|n|nSkip.tests.cpp:<line number>|nexplicit skip']
+##teamcity[testFinished name='tests can be skipped dynamically at runtime' duration="{duration}"]
##teamcity[testStarted name='thrown std::strings are translated']
-Exception.tests.cpp:<line number>|nunexpected exception with message:|n "Why would you throw a std::string?"']
+##teamcity[testFailed name='thrown std::strings are translated' message='Exception.tests.cpp:<line number>|n...............................................................................|n|nException.tests.cpp:<line number>|nunexpected exception with message:|n "Why would you throw a std::string?"']
##teamcity[testFinished name='thrown std::strings are translated' duration="{duration}"]
##teamcity[testStarted name='toString on const wchar_t const pointer returns the string contents']
##teamcity[testFinished name='toString on const wchar_t const pointer returns the string contents' duration="{duration}"]
diff --git a/packages/Catch2/tests/SelfTest/Baselines/xml.sw.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/xml.sw.approved.txt
index 0167e59cf285122303ba0e3cd67122ba72d78594..bf9cf2053f7aaca5fe91b2cadcd3e8d5bb3ef82c 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/xml.sw.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/xml.sw.approved.txt
@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
-<Catch2TestRun name="<exe-name>" rng-seed="1" catch2-version="<version>" filters="~[!nonportable]~[!benchmark]~[approvals] *">
+<Catch2TestRun name="<exe-name>" rng-seed="1" xml-format-version="3" catch2-version="<version>" filters=""*" ~[!nonportable] ~[!benchmark] ~[approvals]">
<TestCase name="# A test name that starts with a #" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1027: Bitfields can be captured" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -20,7 +20,7 @@
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1147" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -71,16 +71,16 @@
{?} >= {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1175 - Hidden Test" tags="[.]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1238" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
uarr := "123"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
sarr := "456"
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -91,10 +91,10 @@
0 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
uarr := "123"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
sarr := "456"
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -105,16 +105,16 @@
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1245" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1319: Sections can have description (even if it is not saved" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Section name="SectionName" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1403" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -125,24 +125,24 @@
[1403 helper] == [1403 helper]
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1455 - INFO and WARN can start with a linebreak" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This info message starts with a linebreak
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This warning message starts with a linebreak
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="#1514: stderr/stdout is not captured in tests aborted by an exception" tags="[.][output-capture][regression]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
1514
</Failure>
- <OverallResult success="false">
+ <OverallResult success="false" skips="0">
<StdOut>
This would not be caught previously
</StdOut>
@@ -160,10 +160,10 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="#1905 -- test spec parser properly clears internal state between compound tests" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <TestCase name="#1905 -- test spec parser properly clears internal state between compound tests" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase("spec . char"))
</Original>
@@ -171,7 +171,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase("spec , char"))
</Original>
@@ -179,7 +179,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
!(spec.matches(*fakeTestCase(R"(spec \, char)")))
</Original>
@@ -187,11 +187,11 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="#1912 -- test spec parser handles escaping" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="Various parentheses" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <TestCase name="#1912 -- test spec parser handles escaping" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Section name="Various parentheses" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase(R"(spec {a} char)"))
</Original>
@@ -199,7 +199,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase(R"(spec [a] char)"))
</Original>
@@ -207,7 +207,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
!(spec.matches(*fakeTestCase("differs but has similar tag", "[a]")))
</Original>
@@ -215,10 +215,10 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="backslash in test name" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="backslash in test name" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase(R"(spec \ char)"))
</Original>
@@ -226,9 +226,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1913 - GENERATE inside a for loop should not keep recreating the generator" tags="[generators][regression]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -247,7 +247,7 @@ Nor would this
6 < 7
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1913 - GENERATEs can share a line" tags="[generators][regression]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -282,11 +282,11 @@ Nor would this
2 != 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - GENERATE after a section" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -297,7 +297,7 @@ Nor would this
1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -308,7 +308,7 @@ Nor would this
2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -319,9 +319,9 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - Section followed by flat generate" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -333,7 +333,7 @@ Nor would this
1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -351,7 +351,7 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - flat generate" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -378,100 +378,100 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - mixed sections and generates" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - nested generate" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -618,16 +618,16 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0" tags="[.][compilation][regression]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0" tags="[.][compilation][regression]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0" tags="[.][compilation][regression]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#2152 - ULP checks between differently signed values were wrong - double" tags="[floating-point][matchers][ulp]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -646,7 +646,7 @@ Nor would this
0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-324, -0.0000000000000000e+00])
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#2152 - ULP checks between differently signed values were wrong - float" tags="[floating-point][matchers][ulp]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -665,20 +665,26 @@ Nor would this
0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00])
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="#2615 - Throwing in constructor generator fails test case but does not abort" tags="[!shouldfail]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
+ <Exception filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
+ failure to init
+ </Exception>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#748 - captures with unexpected exceptions" tags="[!shouldfail][!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Section name="outside assertions" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
answer := 42
</Info>
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
expected exception
</Exception>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="inside REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
answer := 42
</Info>
<Expression success="false" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -692,10 +698,10 @@ Nor would this
expected exception
</Exception>
</Expression>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="inside REQUIRE_THROWS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
answer := 42
</Info>
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -706,9 +712,9 @@ Nor would this
thisThrows()
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#809" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -719,7 +725,7 @@ Nor would this
42 == {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#833" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -778,7 +784,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#835 -- errno should not be touched by Catch2" tags="[!shouldfail][.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -797,10 +803,10 @@ Nor would this
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#872" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
dummy := 0
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -811,25 +817,25 @@ Nor would this
{?} == 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#961 -- Dynamically created sections should all be reported" tags="[.]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="Looped section 0" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 1" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 2" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 3" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 4" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="'Not' checks that should fail" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -896,7 +902,7 @@ Nor would this
!(1 == 1)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="'Not' checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -963,7 +969,7 @@ Nor would this
!(1 == 2)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="(unimplemented) static bools can be evaluated" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Section name="compare to true" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -983,7 +989,7 @@ Nor would this
true == true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="compare to false" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1002,7 +1008,7 @@ Nor would this
false == false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="negation" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1013,7 +1019,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="double negation" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1024,7 +1030,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="direct" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1043,9 +1049,9 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="3x3x3 ints" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -1696,7 +1702,7 @@ Nor would this
3 < 9
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A METHOD_AS_TEST_CASE based test run that fails" tags="[.][class][failing]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1707,7 +1713,7 @@ Nor would this
"hello" == "world"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A METHOD_AS_TEST_CASE based test run that succeeds" tags="[class]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1718,7 +1724,7 @@ Nor would this
"hello" == "hello"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1729,7 +1735,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1740,7 +1746,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1751,7 +1757,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1762,7 +1768,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1773,7 +1779,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1784,7 +1790,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1795,7 +1801,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1806,7 +1812,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1817,7 +1823,7 @@ Nor would this
6 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1828,7 +1834,7 @@ Nor would this
2 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1839,7 +1845,7 @@ Nor would this
6 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1850,7 +1856,7 @@ Nor would this
2 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1861,7 +1867,7 @@ Nor would this
6 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1872,7 +1878,7 @@ Nor would this
2 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1883,7 +1889,7 @@ Nor would this
6 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1894,7 +1900,7 @@ Nor would this
2 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - double" tags="[.][class][failing][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1905,7 +1911,7 @@ Nor would this
1.0 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - float" tags="[.][class][failing][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1916,7 +1922,7 @@ Nor would this
1.0f == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - int" tags="[.][class][failing][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1927,7 +1933,7 @@ Nor would this
1 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double" tags="[class][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1938,7 +1944,7 @@ Nor would this
1.0 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float" tags="[class][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1949,7 +1955,7 @@ Nor would this
1.0f == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int" tags="[class][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1960,7 +1966,7 @@ Nor would this
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1" tags="[.][class][failing][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1971,7 +1977,7 @@ Nor would this
1 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3" tags="[.][class][failing][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1982,7 +1988,7 @@ Nor would this
3 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6" tags="[.][class][failing][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1993,7 +1999,7 @@ Nor would this
6 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1" tags="[class][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2004,7 +2010,7 @@ Nor would this
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3" tags="[class][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2015,7 +2021,7 @@ Nor would this
3 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6" tags="[class][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2026,7 +2032,7 @@ Nor would this
6 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEST_CASE_METHOD based test run that fails" tags="[.][class][failing]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2037,7 +2043,7 @@ Nor would this
1 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEST_CASE_METHOD based test run that succeeds" tags="[class]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2048,7 +2054,7 @@ Nor would this
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - Foo<float>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2059,7 +2065,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - Foo<int>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2070,7 +2076,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - std::vector<float>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2081,7 +2087,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - std::vector<int>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2092,7 +2098,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - Bar<float, 42>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2103,7 +2109,7 @@ Nor would this
42 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - Bar<int, 9>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2114,7 +2120,7 @@ Nor would this
9 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - std::array<float, 42>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2125,7 +2131,7 @@ Nor would this
42 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - std::array<int, 9>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2136,7 +2142,7 @@ Nor would this
9 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A comparison that uses literals instead of the normal constructor" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2187,19 +2193,19 @@ Nor would this
1.23 == Approx( 1.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A couple of nested sections followed by a failure" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="Outer" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="Inner" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Failure filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
to infinity and beyond
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A failing expression with a non streamable type is still captured" tags="[.][failing][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -2218,7 +2224,7 @@ Nor would this
{?} == {?}
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Absolute margin" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2269,10 +2275,10 @@ Nor would this
100.3 == Approx( 100.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="An empty test with no assertions" tags="[empty]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="An expression with side-effects should only be evaluated once" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -2291,7 +2297,7 @@ Nor would this
8 == 8
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="An unchecked exception reports the line of the last assertion" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -2313,10 +2319,10 @@ Nor would this
unexpected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Anonymous test case 1" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approx setters validate their arguments" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2375,7 +2381,7 @@ Nor would this
Approx(0).epsilon(1.0001), std::domain_error
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approx with exactly-representable margin" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2418,7 +2424,7 @@ Nor would this
245.5f == Approx( 245.25 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate PI" tags="[Approx][PI]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2437,7 +2443,7 @@ Nor would this
3.1428571429 != Approx( 3.141 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with different epsilons" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2456,7 +2462,7 @@ Nor would this
1.23 == Approx( 1.231 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with floats" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2475,7 +2481,7 @@ Nor would this
0.0f == Approx( 0.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with ints" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2494,7 +2500,7 @@ Nor would this
0 == Approx( 0.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with mixed numeric types" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2537,7 +2543,7 @@ Nor would this
1.234 == Approx( 1.2339999676 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Arbitrary predicate matcher" tags="[generic][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Function pointer" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -2557,7 +2563,7 @@ Nor would this
1 not matches predicate: "always false"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Lambdas + different type" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -2576,9 +2582,9 @@ Nor would this
"This wouldn't pass" not matches undescribed predicate
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Assertion macros support bit operators and bool conversions" tags="[bitops][compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -2621,7 +2627,7 @@ Nor would this
!(Val: 1 ^ Val: 1)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Assertions then sections" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -2650,9 +2656,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Original>
@@ -2680,11 +2686,11 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Basic use of the Contains range matcher" tags="[contains][matchers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Different argument ranges, same element type, default comparison" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2712,7 +2718,7 @@ Nor would this
{ 4, 5, 6 } not contains element 1
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different argument ranges, same element type, custom comparison" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2739,7 +2745,7 @@ Nor would this
{ 4, 5, 6 } not contains element 0
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different element type, custom comparisons" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2750,7 +2756,7 @@ Nor would this
{ "abc", "abcd", "abcde" } contains element 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Can handle type that requires ADL-found free function begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2769,7 +2775,7 @@ Nor would this
{ 1, 2, 3, 4, 5 } not contains element 8
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Initialization with move only types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2788,7 +2794,7 @@ Nor would this
{ 1, 2, 3 } not contains element 9
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Matching using matcher" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2799,9 +2805,9 @@ Nor would this
{ 1.0, 2.0, 3.0, 0.0 } contains element matching is within 0.5 of 0.5
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Basic use of the Empty range matcher" tags="[empty][matchers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Simple, std-provided containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2853,7 +2859,7 @@ Nor would this
{ } is empty
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type with empty" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2864,7 +2870,7 @@ Nor would this
{?} not is empty
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found empty free function" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2875,97 +2881,97 @@ Nor would this
{?} is empty
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CAPTURE can deal with complex expressions" tags="[capture][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
b := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
c := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a + b := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a+b := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
c > b := true
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a == 1 := true
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CAPTURE can deal with complex expressions involving commas" tags="[capture][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
std::vector<int>{1, 2, 3}[0, 1, 2] := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
std::vector<int>{1, 2, 3}[(0, 1)] := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
std::vector<int>{1, 2, 3}[0] := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(helper_1436<int, int>{12, -12}) := { 12, -12 }
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(helper_1436<int, int>(-12, 12)) := { -12, 12 }
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(1, 2) := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(2, 3) := 3
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CAPTURE parses string and character constants" tags="[capture][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
("comma, in string", "escaped, \", ") := "escaped, ", "
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
"single quote in string,'," := "single quote in string,',"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
"some escapes, \\,\\\\" := "some escapes, \,\\"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
"some, ), unmatched, } prenheses {[<" := "some, ), unmatched, } prenheses {[<"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'"' := '"'
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'\'' := '''
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
',' := ','
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'}' := '}'
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
')' := ')'
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'(' := '('
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'{' := '{'
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Capture and info messages" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Capture should stringify like assertions" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
i := 2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -2976,10 +2982,10 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Info should NOT stringify the way assertions do" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -2990,9 +2996,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CaseInsensitiveEqualsTo is case insensitive" tags="[comparisons][string-case]" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Section name="Degenerate cases" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3012,7 +3018,7 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Plain comparisons" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3063,9 +3069,9 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CaseInsensitiveLess is case insensitive" tags="[comparisons][string-case]" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Section name="Degenerate cases" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3093,7 +3099,7 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Plain comparisons" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3128,9 +3134,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Character pretty printing" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Specifically escaped" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -3166,7 +3172,7 @@ Nor would this
'\f' == '\f'
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="General chars" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -3209,7 +3215,7 @@ Nor would this
'Z' == 'Z'
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Low ASCII" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -3252,9 +3258,9 @@ Nor would this
5 == 5
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Clara::Arg supports single-arg parse the way Opt does" tags="[arg][clara][compilation]" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
@@ -3273,7 +3279,7 @@ Nor would this
"foo" == "foo"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Clara::Opt supports accept-many lambdas" tags="[clara][opt]" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
<Section name="Parsing fails on multiple options without accept_many" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
@@ -3285,7 +3291,7 @@ Nor would this
!{?}
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Parsing succeeds on multiple options with accept_many" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
@@ -3304,9 +3310,9 @@ Nor would this
{ "aaa", "bbb" } == { "aaa", "bbb" }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="ColourGuard behaviour" tags="[console-colours]" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
<Section name="ColourGuard is disengaged by default" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
@@ -3318,7 +3324,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ColourGuard is engaged by op<<" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
@@ -3341,7 +3347,7 @@ Using code: 0
"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ColourGuard can be engaged explicitly" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
@@ -3364,9 +3370,9 @@ C
"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining MatchAllOfGeneric does not nest" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3393,7 +3399,7 @@ C
1 ( equals: (int) 1 or (string) "1" and equals: (long long) 1 and equals: (T) 1 and equals: true )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining MatchAnyOfGeneric does not nest" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3420,7 +3426,7 @@ C
1 ( equals: (int) 1 or (string) "1" or equals: (long long) 1 or equals: (T) 1 or equals: true )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining MatchNotOfGeneric does not nest" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3455,10 +3461,10 @@ C
1 equals: (int) 1 or (string) "1"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining concrete matchers does not use templated matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining only templated matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3485,7 +3491,7 @@ C
1 ( equals: (int) 1 or (string) "1" or not equals: (long long) 1 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining templated and concrete matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3544,7 +3550,7 @@ C
"foobar" ( ( starts with: "foo" and ends with: "bar" ) or Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining templated matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3555,7 +3561,7 @@ C
{ 1, 2, 3 } ( Equals: { 1, 2, 3 } or Equals: { 0, 1, 2 } or Equals: { 4, 5, 6 } )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Commas in various macros are allowed" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -3654,7 +3660,7 @@ C
{ 1, 2 } == { 1, 2 }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparing function pointers" tags="[function pointer][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -3673,7 +3679,7 @@ C
0x<hex digits> == 0x<hex digits>
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparison ops" tags="[rng]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -3708,7 +3714,7 @@ C
!({?} != {?})
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparison with explicitly convertible types" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -3807,7 +3813,7 @@ C
Approx( 11.0 ) >= StrongDoubleTypedef(10)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparisons between ints where one side is computed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -3818,7 +3824,7 @@ C
54 == 54
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -3869,7 +3875,7 @@ C
-2147483648 > 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparisons with int literals don't warn when mixing signed/ unsigned" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -3976,7 +3982,7 @@ C
4294967295 (0x<hex digits>) > 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Composed generic matchers shortcircuit" tags="[composed][generic][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="MatchAllOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4004,7 +4010,7 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="MatchAnyOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4031,9 +4037,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Composed matchers shortcircuit" tags="[composed][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="MatchAllOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4061,7 +4067,7 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="MatchAnyOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4088,9 +4094,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Contains string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4109,7 +4115,7 @@ C
"this string contains 'abc' as a substring" contains: "STRING"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Copy and then generate a range" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4121,7 +4127,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4132,7 +4138,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4143,7 +4149,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4154,7 +4160,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4165,7 +4171,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4176,7 +4182,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4187,7 +4193,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4198,7 +4204,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4209,7 +4215,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4220,7 +4226,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4231,7 +4237,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4242,7 +4248,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Final validation" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4261,9 +4267,9 @@ C
6 == 6
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Cout stream properly declares it writes to stdout" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -4274,7 +4280,7 @@ C
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Custom exceptions can be translated when testing for nothrow" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4288,7 +4294,7 @@ C
custom exception - not std
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Custom exceptions can be translated when testing for throwing as something else" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4302,13 +4308,13 @@ C
custom exception - not std
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Custom std-exceptions can be custom translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
custom std exception
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Default scale is invisible to comparison" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -4327,7 +4333,7 @@ C
0.00001 != Approx( 0.0000001 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Directly creating an EnumInfo" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -4356,7 +4362,13 @@ C
"{** unexpected enum value **}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Empty generators can SKIP in constructor" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ This generator is empty
+ </Skip>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="Empty stream name opens cout stream" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -4367,18 +4379,7 @@ C
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Empty tag is not allowed" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
- <Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
- <Original>
- Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
- </Original>
- <Expanded>
- Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
- </Expanded>
- </Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="EndsWith string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4397,7 +4398,7 @@ C
"this string contains 'abc' as a substring" ends with: "this" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Enums can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -4442,7 +4443,7 @@ C
"Value2" == "Value2"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -4461,7 +4462,7 @@ C
"Blue" == "Blue"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Epsilon only applies to Approx's value" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -4472,7 +4473,7 @@ C
101.01 != Approx( 100.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equality checks that should fail" tags="[!mayfail][.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -4579,7 +4580,7 @@ C
1.3 == Approx( 1.301 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equality checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -4638,7 +4639,7 @@ C
1.3 == Approx( 1.3 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equals" tags="[matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4657,7 +4658,7 @@ C
"this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equals string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4676,7 +4677,7 @@ C
"this string contains 'abc' as a substring" equals: "something else" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified" tags="[exception][toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -4707,7 +4708,7 @@ C
"StringMakerException"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Exception matchers that fail" tags="[!throws][.][exceptions][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="No exception" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4727,7 +4728,7 @@ C
doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type mismatch" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4752,7 +4753,7 @@ C
Unknown exception
</Exception>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contents are wrong" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4771,9 +4772,9 @@ C
SpecialException::what special exception has value of 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Exception matchers that succeed" tags="[!throws][exceptions][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4792,7 +4793,42 @@ C
SpecialException::what special exception has value of 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Exception message can be matched" tags="[!throws][exceptions][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) )
+ </Original>
+ <Expanded>
+ DerivedException::what matches "starts with: "Derived""
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) )
+ </Original>
+ <Expanded>
+ DerivedException::what matches "ends with: "::what""
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) )
+ </Original>
+ <Expanded>
+ DerivedException::what matches "not starts with: "::what""
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) )
+ </Original>
+ <Expanded>
+ SpecialException::what matches "starts with: "Special""
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Exception messages can be tested for" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Section name="exact match" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4804,7 +4840,7 @@ C
"expected exception" equals: "expected exception"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="different case" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4815,7 +4851,7 @@ C
"expected exception" equals: "expected exception" (case insensitive)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="wildcarded" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4850,9 +4886,9 @@ C
"expected exception" contains: "except" (case insensitive)
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Exceptions matchers" tags="[!throws][exceptions][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4887,7 +4923,7 @@ C
SpecialException::what exception message matches "SpecialException::what"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Expected exceptions that don't throw or unexpected exceptions fail the test" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="CHECK_THROWS_AS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4920,26 +4956,26 @@ C
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="FAIL aborts the test" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This is a failure
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="FAIL does not require an argument" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" />
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="FAIL_CHECK does not abort the test" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This is a failure
</Failure>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This message appears in the output
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Factorials are computed" tags="[factorial]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -4982,7 +5018,18 @@ C
3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Filter generator throws exception for empty generator" tags="[generators]" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
+ <Original>
+ filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
+ </Original>
+ <Expanded>
+ filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Floating point matchers: double" tags="[floating-point][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Relative" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5027,9 +5074,9 @@ C
0.0 and 2.22507e-308 are within 2.22045e-12% of each other
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Margin" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5096,7 +5143,7 @@ C
-10.0 is within 0.5 of -9.6
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ULPs" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5155,7 +5202,7 @@ C
-0.0 is within 0 ULPs of 0.0000000000000000e+00 ([0.0000000000000000e+00, 0.0000000000000000e+00])
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Composed" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5182,7 +5229,7 @@ C
0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Constructor validation" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5233,9 +5280,20 @@ C
WithinRel( 1., 1. ), std::domain_error
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="IsNaN" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ 1., !IsNaN()
+ </Original>
+ <Expanded>
+ 1.0 not is NaN
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Floating point matchers: float" tags="[floating-point][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Relative" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5280,9 +5338,9 @@ C
0.0f and 1.17549e-38 are within 0.00119209% of each other
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Margin" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5357,7 +5415,7 @@ C
-10.0f is within 0.5 of -9.6000003815
</Expanded>
</Expression>
- <OverallResults successes="9" failures="0" expectedFailures="0"/>
+ <OverallResults successes="9" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ULPs" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5424,7 +5482,7 @@ C
-0.0f is within 0 ULPs of 0.00000000e+00f ([0.00000000e+00, 0.00000000e+00])
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Composed" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5451,7 +5509,7 @@ C
0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Constructor validation" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5510,9 +5568,20 @@ C
WithinRel( 1.f, 1.f ), std::domain_error
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="IsNaN" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ 1., !IsNaN()
+ </Original>
+ <Expanded>
+ 1.0 not is NaN
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Generators -- adapters" tags="[generators][generic]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5525,9 +5594,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5539,9 +5608,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5553,9 +5622,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Throws if there are no matching values" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5567,9 +5636,9 @@ C
filter([] (int) {return false; }, value(1)), Catch::GeneratorException
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortening a range" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5580,7 +5649,7 @@ C
1 < 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortening a range" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5591,7 +5660,7 @@ C
2 < 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortening a range" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5602,7 +5671,7 @@ C
3 < 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Same type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5614,9 +5683,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Same type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5628,9 +5697,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Same type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5642,9 +5711,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5656,9 +5725,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5670,9 +5739,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5684,9 +5753,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different deduced type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5698,9 +5767,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different deduced type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5712,9 +5781,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different deduced type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5726,9 +5795,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5739,7 +5808,7 @@ C
1 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5750,7 +5819,7 @@ C
2 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5761,7 +5830,7 @@ C
3 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5772,7 +5841,7 @@ C
1 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5783,7 +5852,7 @@ C
2 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5794,7 +5863,7 @@ C
3 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5814,9 +5883,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5836,9 +5905,9 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5858,9 +5927,9 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is not divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5888,9 +5957,9 @@ C
1 < 3
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is not divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5918,9 +5987,9 @@ C
2 < 3
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Chunk size of zero" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5932,9 +6001,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Chunk size of zero" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5946,9 +6015,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Chunk size of zero" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5960,9 +6029,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Throws on too small generators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5974,11 +6043,11 @@ C
chunk(2, value(1)), Catch::GeneratorException
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Generators -- simple" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5990,7 +6059,7 @@ C
-3 < 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6001,7 +6070,7 @@ C
-2 < 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6012,7 +6081,7 @@ C
-1 < 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6023,7 +6092,7 @@ C
4 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6034,7 +6103,7 @@ C
4 > 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6045,7 +6114,7 @@ C
4 > 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6056,7 +6125,7 @@ C
-3 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6067,7 +6136,7 @@ C
-2 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6078,7 +6147,7 @@ C
-1 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6089,7 +6158,7 @@ C
8 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6100,7 +6169,7 @@ C
8 > 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6111,7 +6180,7 @@ C
8 > 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6122,7 +6191,7 @@ C
-3 < 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6133,7 +6202,7 @@ C
-2 < 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6144,7 +6213,7 @@ C
-1 < 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6155,7 +6224,7 @@ C
12 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6166,7 +6235,7 @@ C
12 > 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6177,9 +6246,9 @@ C
12 > 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Generators internals" tags="[generators][internals]" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Single value" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6199,7 +6268,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Preset values" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6250,7 +6319,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Generator combinator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6333,7 +6402,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Explicitly typed generator sequence" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6392,7 +6461,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filter generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Simple filtering" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6428,9 +6497,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filter generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Filter out multiple elements at the start and end" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6466,9 +6535,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filter generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Throws on construction if it can't get initial element" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6488,9 +6557,9 @@ C
filter([](int) { return false; }, values({ 1, 2, 3 })), Catch::GeneratorException
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Take less" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6526,9 +6595,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Take more" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6548,9 +6617,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Map with explicit return type" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6601,7 +6670,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Map with deduced return type" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6652,7 +6721,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Singular repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6672,9 +6741,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Actual repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6774,9 +6843,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive auto step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6845,11 +6914,11 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative auto step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6918,11 +6987,11 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6992,13 +7061,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7068,13 +7137,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7160,19 +7229,19 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Floating Point" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Exact" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7183,7 +7252,7 @@ C
-1.0 == Approx( -1.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7194,7 +7263,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7205,7 +7274,7 @@ C
-0.9 == Approx( -0.9 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7216,7 +7285,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7227,7 +7296,7 @@ C
-0.8 == Approx( -0.8 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7238,7 +7307,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7249,7 +7318,7 @@ C
-0.7 == Approx( -0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7260,7 +7329,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7271,7 +7340,7 @@ C
-0.6 == Approx( -0.6 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7282,7 +7351,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7293,7 +7362,7 @@ C
-0.5 == Approx( -0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7304,7 +7373,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7315,7 +7384,7 @@ C
-0.4 == Approx( -0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7326,7 +7395,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7337,7 +7406,7 @@ C
-0.3 == Approx( -0.3 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7348,7 +7417,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7359,7 +7428,7 @@ C
-0.2 == Approx( -0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7370,7 +7439,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7381,7 +7450,7 @@ C
-0.1 == Approx( -0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7392,7 +7461,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1.38778e-16
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7403,7 +7472,7 @@ C
-0.0 == Approx( -0.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1.38778e-16
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7414,7 +7483,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7425,7 +7494,7 @@ C
0.1 == Approx( 0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7436,7 +7505,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7447,7 +7516,7 @@ C
0.2 == Approx( 0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7458,7 +7527,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7469,7 +7538,7 @@ C
0.3 == Approx( 0.3 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7480,7 +7549,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7491,7 +7560,7 @@ C
0.4 == Approx( 0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7502,7 +7571,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7513,7 +7582,7 @@ C
0.5 == Approx( 0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7524,7 +7593,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7535,7 +7604,7 @@ C
0.6 == Approx( 0.6 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7546,7 +7615,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7557,7 +7626,7 @@ C
0.7 == Approx( 0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7568,7 +7637,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7579,7 +7648,7 @@ C
0.8 == Approx( 0.8 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7590,7 +7659,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7601,7 +7670,7 @@ C
0.9 == Approx( 0.9 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7628,19 +7697,19 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Floating Point" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Slightly over end" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7651,7 +7720,7 @@ C
-1.0 == Approx( -1.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7662,7 +7731,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7673,7 +7742,7 @@ C
-0.7 == Approx( -0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7684,7 +7753,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7695,7 +7764,7 @@ C
-0.4 == Approx( -0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7706,7 +7775,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7717,7 +7786,7 @@ C
-0.1 == Approx( -0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7728,7 +7797,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7739,7 +7808,7 @@ C
0.2 == Approx( 0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7750,7 +7819,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7761,7 +7830,7 @@ C
0.5 == Approx( 0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7780,19 +7849,19 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Floating Point" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Slightly under end" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7803,7 +7872,7 @@ C
-1.0 == Approx( -1.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7814,7 +7883,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7825,7 +7894,7 @@ C
-0.7 == Approx( -0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7836,7 +7905,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7847,7 +7916,7 @@ C
-0.4 == Approx( -0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7858,7 +7927,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7869,7 +7938,7 @@ C
-0.1 == Approx( -0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7880,7 +7949,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7891,7 +7960,7 @@ C
0.2 == Approx( 0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7902,7 +7971,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7913,7 +7982,7 @@ C
0.5 == Approx( 0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7932,13 +8001,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -8008,13 +8077,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -8084,13 +8153,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -8176,15 +8245,15 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Greater-than inequalities with different epsilons" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -8219,7 +8288,7 @@ C
1.23 >= Approx( 1.24 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashers with different seed produce different hash with same test case" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8232,7 +8301,7 @@ C
130711275 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashers with same seed produce same hash" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8245,7 +8314,7 @@ C
3422778688 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashing different test cases produces different result" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Section name="Different test name" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8259,7 +8328,7 @@ C
2668622104 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different classname" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8272,7 +8341,7 @@ C
3916075712 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different tags" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8285,9 +8354,9 @@ C
3429949824 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashing test case produces same hash across multiple calls" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8300,22 +8369,22 @@ C
3422778688 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="INFO and WARN do not abort tests" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this is a message
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this is a warning
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="INFO gets logged on failure" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
so should this
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8326,10 +8395,10 @@ C
2 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="INFO gets logged on failure, even if captured before successful assertions" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8340,10 +8409,10 @@ C
2 == 2
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8354,13 +8423,13 @@ C
2 == 1
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
and this, but later
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8371,16 +8440,16 @@ C
2 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
and this, but later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
but not this
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8391,13 +8460,13 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="INFO is reset for each loop" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 0
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 0
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8408,10 +8477,10 @@ C
0 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8422,10 +8491,10 @@ C
1 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8436,10 +8505,10 @@ C
2 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8450,10 +8519,10 @@ C
3 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8464,10 +8533,10 @@ C
4 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8478,10 +8547,10 @@ C
5 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 6
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8492,10 +8561,10 @@ C
6 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 7
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8506,10 +8575,10 @@ C
7 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 8
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8520,10 +8589,10 @@ C
8 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 9
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8534,10 +8603,10 @@ C
9 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 10
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 10
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8548,7 +8617,7 @@ C
10 < 10
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Inequality checks that should fail" tags="[!shouldfail][.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -8591,7 +8660,7 @@ C
5 != 5
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Inequality checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -8682,7 +8751,7 @@ C
5 != 6
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Lambdas in assertions" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -8693,7 +8762,7 @@ C
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Less-than inequalities with different epsilons" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -8728,10 +8797,10 @@ C
1.23 <= Approx( 1.22 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="ManuallyRegistered" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be (AllOf) composed with the && operator" tags="[matchers][operator&&][operators]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8742,7 +8811,7 @@ C
"this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" and contains: "substring" and contains: "contains" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be (AnyOf) composed with the || operator" tags="[matchers][operators][operator||]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8761,7 +8830,7 @@ C
"some completely different text that contains one common word" ( contains: "string" or contains: "different" or contains: "random" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be composed with both && and ||" tags="[matchers][operator&&][operators][operator||]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8772,7 +8841,7 @@ C
"this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "substring" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be composed with both && and || - failing" tags="[.][failing][matchers][operator&&][operators][operator||]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8783,7 +8852,7 @@ C
"this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Matchers can be negated (Not) with the ! operator" tags="[matchers][not][operators]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8794,7 +8863,7 @@ C
"this string contains 'abc' as a substring" not contains: "different"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be negated (Not) with the ! operator - failing" tags="[.][failing][matchers][not][operators]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8805,44 +8874,44 @@ C
"this string contains 'abc' as a substring" not contains: "substring"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Mayfail test case with nested sections" tags="[!mayfail]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="1" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="A" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="2" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="A" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
- <OverallResults successes="0" failures="0" expectedFailures="0"/>
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="1" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="2" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
- <OverallResults successes="0" failures="0" expectedFailures="0"/>
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Mismatching exception messages failing the test" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -8861,7 +8930,7 @@ C
"expected exception" equals: "should fail"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Multireporter calls reporters and listeners in correct order" tags="[multi-reporter][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -8874,7 +8943,7 @@ C
{ "Hello", "world", "Goodbye", "world" }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Multireporter updates ReporterPreferences properly" tags="[multi-reporter][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -8942,7 +9011,7 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -9009,9 +9078,9 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Nested generators and captured variables" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -9142,19 +9211,19 @@ C
99 > -6
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Nice descriptive name" tags="[.][tag1][tag2][tag3]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
This one ran
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Non-std exceptions can be translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
custom exception
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Objects that evaluated in boolean contexts can be checked" tags="[SafeBool][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -9181,10 +9250,10 @@ C
!{?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Optionally static assertions" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Ordering comparison checks that should fail" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -9339,7 +9408,7 @@ C
"hello" <= "a"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Ordering comparison checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -9478,7 +9547,7 @@ C
"hello" > "a"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Our PCG implementation provides expected results for known seeds" tags="[rng]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Section name="Default seeded" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -9532,7 +9601,7 @@ C
1827115164 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Specific seed" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -9635,24 +9704,24 @@ C
4261393167 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Output from all sections is reported" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Section name="one" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Message from section one
</Failure>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Message from section two
</Failure>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Overloaded comma or address-of operators are not used" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -9687,1548 +9756,329 @@ C
( EvilMatcher() && EvilMatcher() ) || !EvilMatcher()
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="Parse test names and tags" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="Empty test spec should have no filters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <TestCase name="Parse uints" tags="[parse-numbers]" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
+ <Section name="proper inputs" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == false
+ parseUInt( "0" ) == Optional<unsigned int>{ 0 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ parseUInt( "100" ) == Optional<unsigned int>{ 100 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from empty string should have no filters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == false
+ parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Bad inputs" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(parseUInt( "" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ !(parseUInt( "!!KJHF*#" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from just a comma should have no filters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == false
+ !(parseUInt( "-1" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(parseUInt( "4294967296" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ !(parseUInt( "42949672964294967296429496729642949672964294967296" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from name should have one filter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ !(parseUInt( "2 4" ))
</Original>
<Expanded>
- true == true
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(parseUInt( "0x<hex digits>", 10 ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsed tags are matched case insensitive" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.hasFilters()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.getInvalidSpecs().empty()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.matches( testCase )
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsing sharding-related cli flags" tags="[sharding]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="shard-count" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == true
+ cli.parse({ "test", "--shard-count=8" })
</Original>
<Expanded>
- true == true
+ {?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from quoted name should have one filter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ config.shardCount == 8
</Original>
<Expanded>
- true == true
+ 8 == 8
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Negative shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(result)
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == true
+ result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" )
</Original>
<Expanded>
- true == true
+ "Could not parse '-1' as shard count" contains: "Could not parse '-1' as shard count"
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Test spec from name should have one filter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="Zero shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ !(result)
</Original>
<Expanded>
- true == true
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ result.errorMessage(), ContainsSubstring( "Shard count must be positive" )
</Original>
<Expanded>
- false == false
+ "Shard count must be positive" contains: "Shard count must be positive"
</Expanded>
</Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="shard-index" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == true
+ cli.parse({ "test", "--shard-index=2" })
</Original>
<Expanded>
- true == true
+ {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcC ) == false
+ config.shardIndex == 2
</Original>
<Expanded>
- false == false
+ 2 == 2
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Wildcard at the start" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="Negative shard index reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ !(result)
</Original>
<Expanded>
- true == true
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" )
</Original>
<Expanded>
- false == false
+ "Could not parse '-12' as shard index" contains: "Could not parse '-12' as shard index"
</Expanded>
</Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Shard index 0 is accepted" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ cli.parse({ "test", "--shard-index=0" })
</Original>
<Expanded>
- false == false
+ {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcC ) == true
+ config.shardIndex == 0
</Original>
<Expanded>
- true == true
+ 0 == 0
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsing tags with non-alphabetical characters is pass-through" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[tag with spaces]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.hasFilters()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[tag with spaces]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.getInvalidSpecs().empty()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[tag with spaces]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.matches( testCase )
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[I said "good day" sir!]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.hasFilters()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[I said "good day" sir!]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.getInvalidSpecs().empty()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[I said "good day" sir!]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.matches( testCase )
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsing warnings" tags="[cli][warnings]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="NoAssertions" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcD ) == false
+ cli.parse( { "test", "-w", "NoAssertions" } )
</Original>
<Expanded>
- false == false
+ {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- parseTestSpec( "*a" ).matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcard at the end" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- parseTestSpec( "a*" ).matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcard at both ends" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- parseTestSpec( "*a*" ).matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Redundant wildcard at the start" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Redundant wildcard at the end" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Redundant wildcard at both ends" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcard at both ends, redundant at start" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Just wildcard" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Single tag" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Single tag, two matches" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Two tags" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Two tags, spare separated" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcarded name and tag" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Single tag exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="One tag exclusion and one tag inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="One tag exclusion and one wldcarded name inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="One tag exclusion, using exclude:, and one wldcarded name inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="name exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="wildcarded name exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="wildcarded name exclusion with tag inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="wildcarded name exclusion, using exclude:, with tag inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="two wildcarded names" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="empty tag" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="empty quoted name" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="quoted string followed by tag exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Leading and trailing spaces in test spec" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Leading and trailing spaces in test name" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Shortened hide tags are split apart when parsing" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches(*fakeTestCase("hidden and foo", "[.][foo]"))
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("only foo", "[foo]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Shortened hide tags also properly handle exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("only foo", "[foo]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("only hidden", "[.]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]"))
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsed tags are matched case insensitive" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.hasFilters()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.getInvalidSpecs().empty()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.matches( testCase )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsing sharding-related cli flags" tags="[sharding]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="shard-count" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse({ "test", "--shard-count=8" })
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- config.shardCount == 8
- </Original>
- <Expanded>
- 8 == 8
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Negative shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(result)
- </Original>
- <Expanded>
- !{?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- result.errorMessage(), ContainsSubstring("Shard count must be a positive number")
- </Original>
- <Expanded>
- "Shard count must be a positive number" contains: "Shard count must be a positive number"
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Zero shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(result)
- </Original>
- <Expanded>
- !{?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- result.errorMessage(), ContainsSubstring("Shard count must be a positive number")
- </Original>
- <Expanded>
- "Shard count must be a positive number" contains: "Shard count must be a positive number"
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="shard-index" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse({ "test", "--shard-index=2" })
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- config.shardIndex == 2
- </Original>
- <Expanded>
- 2 == 2
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Negative shard index reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(result)
- </Original>
- <Expanded>
- !{?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number")
- </Original>
- <Expanded>
- "Shard index must be a non-negative number" contains: "Shard index must be a non-negative number"
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Shard index 0 is accepted" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse({ "test", "--shard-index=0" })
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- config.shardIndex == 0
- </Original>
- <Expanded>
- 0 == 0
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsing tags with non-alphabetical characters is pass-through" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Info>
- tagString := "[tag with spaces]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.hasFilters()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[tag with spaces]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.getInvalidSpecs().empty()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[tag with spaces]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.matches( testCase )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[I said "good day" sir!]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.hasFilters()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[I said "good day" sir!]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.getInvalidSpecs().empty()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[I said "good day" sir!]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.matches( testCase )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsing warnings" tags="[cli][warnings]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="NoAssertions" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse( { "test", "-w", "NoAssertions" } )
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
config.warnings == WarnAbout::NoAssertions
</Original>
@@ -11236,7 +10086,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="NoTests is no longer supported" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11247,7 +10097,7 @@ C
!{?}
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Combining multiple warnings" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11266,9 +10116,9 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Pointers can be compared to null" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -11335,7 +10185,7 @@ C
0 != 0x<hex digits>
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Precision of floating point stringification can be set" tags="[floatingPoint][toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Floats" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -11355,7 +10205,7 @@ C
13 == 13
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Double" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -11374,9 +10224,9 @@ C
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Predicate matcher can accept const char*" tags="[compilation][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -11387,7 +10237,7 @@ C
"foo" matches undescribed predicate
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Process can be configured on command line" tags="[command-line][config]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="empty args don't cause a crash" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11407,7 +10257,7 @@ C
"" == ""
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="default - no arguments" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11498,7 +10348,7 @@ C
{?} == {?}
</Expanded>
</Expression>
- <OverallResults successes="11" failures="0" expectedFailures="0"/>
+ <OverallResults successes="11" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="test lists" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Specify one test case using" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11534,9 +10384,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="test lists" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Specify one test case exclusion using exclude:" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11572,9 +10422,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="test lists" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Specify one test case exclusion using ~" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11610,13 +10460,13 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-r/console" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11627,7 +10477,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11638,13 +10488,13 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-r/xml" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11655,7 +10505,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11666,13 +10516,13 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--reporter/junit" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11683,7 +10533,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11694,9 +10544,9 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="must match one of the available ones" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11716,13 +10566,13 @@ C
"Unrecognized reporter, 'unsupported'. Check available with --list-reporters" contains: "Unrecognized reporter"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="With output file" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11733,7 +10583,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11744,13 +10594,13 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="With Windows-like absolute path as output file" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11761,7 +10611,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11772,9 +10622,9 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Multiple reporters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11795,11 +10645,11 @@ C
{ {?}, {?} } == { {?}, {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Multiple reporters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11820,11 +10670,11 @@ C
{ {?}, {?} } == { {?}, {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Multiple reporters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11845,11 +10695,11 @@ C
"Only one reporter may have unspecified output file." contains: "Only one reporter may have unspecified output file."
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="debugger" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-b" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11869,9 +10719,9 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="debugger" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--break" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11891,9 +10741,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-a aborts after first failure" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11913,9 +10763,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-x 2 aborts after two failures" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11935,9 +10785,9 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-x must be numeric" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11957,9 +10807,9 @@ C
"Unable to convert 'oops' to destination type" ( contains: "convert" and contains: "oops" )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11980,11 +10830,11 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12005,11 +10855,11 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12030,11 +10880,11 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12055,11 +10905,11 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12080,11 +10930,11 @@ C
"keypress argument must be one of: never, start, exit or both. 'sometimes' not recognised" ( contains: "never" and contains: "both" )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="nothrow" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-e" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12104,9 +10954,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="nothrow" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--nothrow" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12126,9 +10976,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="output filename" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-o filename" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12148,9 +10998,9 @@ C
"filename.ext" == "filename.ext"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="output filename" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--out" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12170,9 +11020,9 @@ C
"filename.ext" == "filename.ext"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="combinations" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Single character flags can be combined" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12208,9 +11058,9 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="without option" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12230,9 +11080,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="auto" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12252,9 +11102,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="yes" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12274,9 +11124,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="no" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12296,9 +11146,9 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12318,9 +11168,9 @@ C
"colour mode must be one of: default, ansi, win32, or none. 'wrong' is not recognised" contains: "colour mode must be one of"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="samples" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12340,9 +11190,9 @@ C
200 == 200
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="resamples" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12362,9 +11212,9 @@ C
20000 (0x<hex digits>) == 20000 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="confidence-interval" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12384,9 +11234,9 @@ C
0.99 == Approx( 0.99 )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="no-analysis" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12406,9 +11256,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="warmup-time" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12428,11 +11278,11 @@ C
10 == 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Product with differing arities - std::tuple<int, double, float>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -12443,7 +11293,7 @@ C
3 >= 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Product with differing arities - std::tuple<int, double>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -12454,7 +11304,7 @@ C
2 >= 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Product with differing arities - std::tuple<int>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -12465,7 +11315,7 @@ C
1 >= 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Random seed generation accepts known methods" tags="[rng][seed]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -12492,7 +11342,7 @@ C
Catch::generateRandomSeed(method)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Random seed generation reports unknown methods" tags="[rng][seed]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -12503,7 +11353,7 @@ C
Catch::generateRandomSeed(static_cast<Catch::GenerateFrom>(77))
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Range type with sentinel" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -12514,7 +11364,7 @@ C
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Reconstruction should be based on stringification: #914" tags="[.][Decomposition][failing]" filename="tests/<exe-name>/UsageTests/Decomposition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Decomposition.tests.cpp" >
@@ -12525,7 +11375,7 @@ C
Hey, its truthy!
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Regex string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -12552,7 +11402,7 @@ C
"this string contains 'abc' as a substring" matches "this string contains 'abc' as a" case sensitively
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Registering reporter with '::' in name fails" tags="[registration][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12563,7 +11413,7 @@ C
"'::' is not allowed in reporter name: 'with::doublecolons'" equals: "'::' is not allowed in reporter name: 'with::doublecolons'"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Regression test #1" tags="[matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -12574,7 +11424,7 @@ C
{ 'a', 'b' } not UnorderedEquals: { 'c', 'b' }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Reporter's write listings to provided stream" tags="[reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12586,7 +11436,7 @@ C
</Expanded>
</Expression>
<Section name="Automake reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: Automake
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12601,7 +11451,7 @@ C
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12612,7 +11462,7 @@ C
</Expanded>
</Expression>
<Section name="Automake reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: Automake
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12626,7 +11476,7 @@ C
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12637,7 +11487,7 @@ C
</Expanded>
</Expression>
<Section name="Automake reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: Automake
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12653,7 +11503,7 @@ C
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12664,7 +11514,7 @@ C
</Expanded>
</Expression>
<Section name="compact reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: compact
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12679,7 +11529,7 @@ C
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12690,7 +11540,7 @@ C
</Expanded>
</Expression>
<Section name="compact reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: compact
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12704,7 +11554,7 @@ C
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12715,7 +11565,7 @@ C
</Expanded>
</Expression>
<Section name="compact reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: compact
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12731,7 +11581,7 @@ C
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12742,7 +11592,7 @@ C
</Expanded>
</Expression>
<Section name="console reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: console
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12757,7 +11607,7 @@ C
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12768,7 +11618,7 @@ C
</Expanded>
</Expression>
<Section name="console reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: console
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12782,7 +11632,7 @@ C
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12793,7 +11643,7 @@ C
</Expanded>
</Expression>
<Section name="console reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: console
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12809,7 +11659,7 @@ C
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12820,7 +11670,7 @@ C
</Expanded>
</Expression>
<Section name="JUnit reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: JUnit
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12836,7 +11686,7 @@ All available tags:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12847,7 +11697,7 @@ All available tags:
</Expanded>
</Expression>
<Section name="JUnit reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: JUnit
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12862,7 +11712,7 @@ Available reporters:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12873,7 +11723,7 @@ Available reporters:
</Expanded>
</Expression>
<Section name="JUnit reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: JUnit
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12890,7 +11740,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12901,7 +11751,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="SonarQube reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: SonarQube
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12917,7 +11767,7 @@ All available tags:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12928,7 +11778,7 @@ All available tags:
</Expanded>
</Expression>
<Section name="SonarQube reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: SonarQube
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12943,7 +11793,7 @@ Available reporters:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12954,7 +11804,7 @@ Available reporters:
</Expanded>
</Expression>
<Section name="SonarQube reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: SonarQube
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12971,7 +11821,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12982,7 +11832,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TAP reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TAP
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12997,7 +11847,7 @@ All available test cases:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13008,7 +11858,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TAP reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TAP
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13022,7 +11872,7 @@ All available test cases:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13033,7 +11883,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TAP reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TAP
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13049,7 +11899,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13060,7 +11910,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TeamCity reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TeamCity
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13075,7 +11925,7 @@ All available test cases:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13086,7 +11936,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TeamCity reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TeamCity
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13100,7 +11950,7 @@ All available test cases:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13111,7 +11961,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TeamCity reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TeamCity
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13127,7 +11977,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13138,7 +11988,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="XML reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: XML
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13157,7 +12007,7 @@ All available test cases:
</TagsFromMatchingTests>" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13168,7 +12018,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="XML reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: XML
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13185,7 +12035,7 @@ All available test cases:
</AvailableReporters>" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13196,7 +12046,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="XML reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: XML
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13218,18 +12068,18 @@ All available test cases:
</MatchingTests>" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla" tags="[console-reporter]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="SUCCEED counts as a test pass" tags="[messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="SUCCEED does not require an argument" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods" tags="[bdd][fixtures]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: No operations precede me" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13251,13 +12101,13 @@ All available test cases:
1 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: Do that thing with the thing" tags="[Tags]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: This stuff exists" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13281,29 +12131,29 @@ All available test cases:
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping" tags="[anotherReallyLongTagNameButThisOneHasNoObviousWrapPointsSoShouldSplitWithinAWordUsingADashCharacter][long][lots][one very long tag name that should cause line wrapping writing out using the list command][tags][verbose][very long tags]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: A section name that is so long that it cannot fit in a single console width" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="When: The test headers are printed as part of the normal running of the scenario" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: Vector resizing affects size and capacity" tags="[bdd][capacity][size][vector]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: an empty vector" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13351,15 +12201,15 @@ All available test cases:
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Given: an empty vector" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13388,16 +12238,16 @@ All available test cases:
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Sends stuff to stdout and stderr" tags="[.]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false">
+ <OverallResult success="false" skips="0">
<StdOut>
A string sent directly to stdout
</StdOut>
@@ -13472,16 +12322,16 @@ A string sent to stderr via clog
Approx( 1.23 ) != 1.24
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Standard output from all sections is reported" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Section name="one" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false">
+ <OverallResult success="false" skips="0">
<StdOut>
Message from section one
Message from section two
@@ -13505,7 +12355,7 @@ Message from section two
"this string contains 'abc' as a substring" starts with: "string" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Static arrays are convertible to string" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Single item" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -13517,7 +12367,7 @@ Message from section two
"{ 1 }" == "{ 1 }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Multiple" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -13528,7 +12378,7 @@ Message from section two
"{ 3, 2, 1 }" == "{ 3, 2, 1 }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Non-trivial inner items" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -13541,9 +12391,9 @@ Message from section two
"{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="String matchers" tags="[matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -13610,7 +12460,7 @@ Message from section two
"this string contains 'abc' as a substring" ends with: " substring" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="StringRef" tags="[StringRef][Strings]" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Empty string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13638,7 +12488,7 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From string literal" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13673,7 +12523,7 @@ Message from section two
"hello" == "hello"
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From sub-string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13692,7 +12542,7 @@ Message from section two
original.data()
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Copy construction is shallow" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13703,7 +12553,7 @@ Message from section two
"original string" == "original string"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Copy assignment is shallow" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13714,7 +12564,7 @@ Message from section two
"original string" == "original string"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="zero-based substring" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13750,9 +12600,9 @@ Message from section two
hello == "hello"
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="non-zero-based substring" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13772,9 +12622,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Pointer values of full refs should match" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13786,9 +12636,9 @@ Message from section two
"hello world!" == "hello world!"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Pointer values of substring refs should also match" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13800,9 +12650,9 @@ Message from section two
"hello world!" == "hello world!"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Past the end substring" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13814,9 +12664,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Substring off the end are trimmed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13828,9 +12678,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="substring start after the end is empty" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13842,9 +12692,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Comparisons are deep" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13871,7 +12721,7 @@ Message from section two
Hello != Hel
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="implicitly constructed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13891,9 +12741,9 @@ Message from section two
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="explicitly constructed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13913,9 +12763,9 @@ Message from section two
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="assigned" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13935,9 +12785,9 @@ Message from section two
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="to std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="explicitly constructed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13957,9 +12807,9 @@ Message from section two
11 == 11
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="to std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="assigned" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13979,9 +12829,9 @@ Message from section two
11 == 11
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="std::string += StringRef" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13994,7 +12844,7 @@ Message from section two
"some string += the stringref contents"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="StringRef + StringRef" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -14005,18 +12855,18 @@ Message from section two
"abrakadabra" == "abrakadabra"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="StringRef at compilation time" tags="[constexpr][StringRef][Strings]" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Simple constructors" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="UDL construction" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying char arrays with statically known sizes - char" tags="[toString]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -14035,7 +12885,7 @@ Message from section two
""abc"" == ""abc""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying char arrays with statically known sizes - signed char" tags="[toString]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -14054,7 +12904,7 @@ Message from section two
""abc"" == ""abc""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying char arrays with statically known sizes - unsigned char" tags="[toString]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -14073,7 +12923,7 @@ Message from section two
""abc"" == ""abc""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying std::chrono::duration helpers" tags="[chrono][toString]" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
@@ -14108,7 +12958,7 @@ Message from section two
1 ns != 1 us
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying std::chrono::duration with weird ratios" tags="[chrono][toString]" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
@@ -14127,7 +12977,7 @@ Message from section two
1 ps != 1 as
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying std::chrono::time_point<system_clock>" tags="[chrono][toString]" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
@@ -14140,7 +12990,7 @@ Message from section two
{iso8601-timestamp}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Tabs and newlines show in output" tags="[.][failing][whitespace]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14158,7 +13008,7 @@ Message from section two
"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Tag alias can be registered against tag patterns" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Section name="The same tag alias can only be registered once" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -14202,7 +13052,7 @@ Message from section two
Redefined at: file:10" contains: "10"
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Tag aliases must be of the form [@name]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="CHECK_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -14237,9 +13087,9 @@ Message from section two
registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) )
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Tags with spaces and non-alphanumerical characters are accepted" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -14258,7 +13108,7 @@ Message from section two
{ {?}, {?} } ( Contains: {?} and Contains: {?} )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case method with test types specified inside std::tuple - MyTypes - 0" tags="[class][list][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -14269,7 +13119,7 @@ Message from section two
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case method with test types specified inside std::tuple - MyTypes - 1" tags="[class][list][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -14280,7 +13130,7 @@ Message from section two
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case method with test types specified inside std::tuple - MyTypes - 2" tags="[class][list][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -14291,7 +13141,7 @@ Message from section two
1.0 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14302,7 +13152,7 @@ Message from section two
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14313,7 +13163,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14324,7 +13174,7 @@ Message from section two
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14335,7 +13185,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside std::tuple - MyTypes - 0" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14346,7 +13196,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside std::tuple - MyTypes - 1" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14357,7 +13207,7 @@ Message from section two
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside std::tuple - MyTypes - 2" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14368,7 +13218,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - float" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14404,7 +13254,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14448,9 +13298,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14485,7 +13335,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14520,9 +13370,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - int" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14558,7 +13408,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14602,9 +13452,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14639,7 +13489,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14674,9 +13524,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - std::string" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14712,7 +13562,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14756,9 +13606,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14793,7 +13643,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14828,9 +13678,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - std::tuple<int,float>" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14866,7 +13716,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14910,9 +13760,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14947,7 +13797,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14982,9 +13832,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15020,7 +13870,7 @@ Message from section two
12 >= 12
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15064,9 +13914,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15101,7 +13951,7 @@ Message from section two
12 >= 12
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15136,9 +13986,9 @@ Message from section two
6 >= 6
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - float,4" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15174,7 +14024,7 @@ Message from section two
8 >= 8
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15218,9 +14068,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15255,7 +14105,7 @@ Message from section two
8 >= 8
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15290,9 +14140,9 @@ Message from section two
4 >= 4
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - int,5" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15328,7 +14178,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15372,9 +14222,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15409,7 +14259,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15444,9 +14294,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - std::string,15" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15482,7 +14332,7 @@ Message from section two
30 >= 30
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15526,9 +14376,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15563,7 +14413,7 @@ Message from section two
30 >= 30
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15598,9 +14448,9 @@ Message from section two
15 >= 15
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test case with identical tags keeps just one" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -15619,10 +14469,10 @@ Message from section two
{?} == {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test case with one argument" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test enum bit values" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -15633,10 +14483,10 @@ Message from section two
3221225472 (0x<hex digits>) == 3221225472
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test with special, characters "in name" tags="[cli][regression]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Testing checked-if" tags="[checked-if]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15671,7 +14521,7 @@ Message from section two
false
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Testing checked-if 2" tags="[!shouldfail][checked-if]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15683,7 +14533,7 @@ Message from section two
</Expanded>
</Expression>
<Failure filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" />
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Testing checked-if 3" tags="[!shouldfail][checked-if]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECKED_ELSE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15695,7 +14545,7 @@ Message from section two
</Expanded>
</Expression>
<Failure filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" />
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="The NO_FAIL macro reports a failure but does not fail the test" tags="[messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Expression success="false" type="CHECK_NOFAIL" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -15706,7 +14556,7 @@ Message from section two
1 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="The default listing implementation write to provided stream" tags="[reporter-helpers][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Section name="Listing tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15722,7 +14572,7 @@ Message from section two
" contains: "[fakeTag]"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Listing reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15736,7 +14586,7 @@ Message from section two
" ( contains: "fake reporter" and contains: "fake description" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Listing tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15752,7 +14602,7 @@ Message from section two
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Listing listeners" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15766,18 +14616,18 @@ Message from section two
" ( contains: "fakeListener" and contains: "fake description" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="This test 'should' fail but doesn't" tags="[!shouldfail][.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Thrown string literals are translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
For some reason someone is throwing a string literal!
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Tracker" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -15829,7 +14679,7 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -15929,9 +14779,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16039,9 +14889,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="11" failures="0" expectedFailures="0"/>
+ <OverallResults successes="11" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16142,11 +14992,11 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16279,11 +15129,11 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="14" failures="0" expectedFailures="0"/>
+ <OverallResults successes="14" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16350,9 +15200,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Trim strings" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -16435,13 +15285,189 @@ There is no extra whitespace here
There is no extra whitespace here
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Type conversions of RangeEquals and similar" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different container types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, RangeEquals( c_array )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, UnorderedRangeEquals( c_array )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different container types (differ in array N)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_3, !RangeEquals( array_int_4 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_3, !UnorderedRangeEquals( array_int_4 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different container types and value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, RangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, UnorderedRangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers, one random access, one not" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, RangeEquals( list_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, UnorderedRangeEquals( list_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, RangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, UnorderedRangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, !RangeEquals( vector_char_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, !UnorderedRangeEquals( vector_char_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Ranges with begin that needs ADL" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ a, !RangeEquals( b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 3, 2, 1 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ a, UnorderedRangeEquals( b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 3, 2, 1 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, RangeEquals( array_a_plus_1, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Unexpected exceptions can be translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
3.14
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Upcasting special member functions" tags="[internals][unique-ptr]" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Section name="Move constructor" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -16453,7 +15479,7 @@ There is no extra whitespace here
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="move assignment" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -16464,9 +15490,9 @@ There is no extra whitespace here
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AllMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16486,7 +15512,7 @@ There is no extra whitespace here
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains element 1 )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16497,7 +15523,7 @@ There is no extra whitespace here
{ 1, 2, 3, 4, 5 } all match matches undescribed predicate
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16549,9 +15575,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16603,11 +15629,11 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AllTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16620,9 +15646,9 @@ There is no extra whitespace here
{ true, true, true, true, true } contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16634,12 +15660,12 @@ There is no extra whitespace here
{ } contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, !AllTrue()
@@ -16648,9 +15674,9 @@ There is no extra whitespace here
{ true, true, false, true, true } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16662,9 +15688,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16676,12 +15702,12 @@ There is no extra whitespace here
{ true, true, true, true, true } contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, !AllTrue()
@@ -16690,9 +15716,9 @@ There is no extra whitespace here
{ true, true, false, true, true } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16704,9 +15730,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16758,9 +15784,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16812,11 +15838,11 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AnyMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16836,7 +15862,7 @@ There is no extra whitespace here
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains element 10 )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16847,7 +15873,7 @@ There is no extra whitespace here
{ 1, 2, 3, 4, 5 } any match matches undescribed predicate
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16899,9 +15925,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16953,11 +15979,11 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AnyTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16970,9 +15996,9 @@ There is no extra whitespace here
{ true, true, true, true, true } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16984,12 +16010,12 @@ There is no extra whitespace here
{ } not contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, AnyTrue()
@@ -16998,9 +16024,9 @@ There is no extra whitespace here
{ false, false, true, false, false } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17012,9 +16038,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17026,12 +16052,12 @@ There is no extra whitespace here
{ true, true, true, true, true } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, AnyTrue()
@@ -17040,9 +16066,9 @@ There is no extra whitespace here
{ false, false, true, false, false } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17054,9 +16080,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17108,9 +16134,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17146,67 +16172,276 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[3])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[4])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Usage of NoneMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, NoneMatch(SizeIs(6))
+ </Original>
+ <Expanded>
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } none match has size == 6
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneMatch(Contains(0) && Contains(1))
+ </Original>
+ <Expanded>
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains element 1 )
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked, noneMatch
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[0]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[1]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[2]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[3]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[4]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked, !noneMatch
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[0]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[1])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[2])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[3])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[4])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Usage of NoneTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneTrue()
+ </Original>
+ <Expanded>
+ { true, true, true, true, true } not contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, NoneTrue()
+ </Original>
+ <Expanded>
+ { } contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneTrue()
+ </Original>
+ <Expanded>
+ { false, false, true, false, false } not contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, NoneTrue()
+ </Original>
+ <Expanded>
+ { false, false, false, false, false } contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneTrue()
+ </Original>
+ <Expanded>
+ { true, true, true, true, true } not contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[3])
+ data, !NoneTrue()
</Original>
<Expanded>
- !false
+ { false, false, true, false, false } not contains no true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[4])
+ data, NoneTrue()
</Original>
<Expanded>
- !false
+ { false, false, false, false, false } contains no true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Usage of NoneMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Original>
- data, NoneMatch(SizeIs(6))
- </Original>
- <Expanded>
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } none match has size == 6
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Original>
- data, !NoneMatch(Contains(0) && Contains(1))
- </Original>
- <Expanded>
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains element 1 )
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Original>
- needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) )
- </Original>
- <Expanded>
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
- </Expanded>
- </Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, noneMatch
+ mocked, NoneTrue()
</Original>
<Expanded>
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ { false, false, false, false, false } contains no true
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17249,18 +16484,18 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, !noneMatch
+ mocked, !NoneTrue()
</Original>
<Expanded>
- { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
+ { false, false, true, true, true } not contains no true
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17271,20 +16506,20 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[1])
+ mocked.m_derefed[1]
</Original>
<Expanded>
- !false
+ true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[2])
+ mocked.m_derefed[2]
</Original>
<Expanded>
- !false
+ true
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17303,132 +16538,173 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="Usage of NoneTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <TestCase name="Usage of RangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ empty_vector, RangeEquals( empty_vector )
</Original>
<Expanded>
- { true, true, true, true, true } not contains no true
+ { } elements are { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, NoneTrue()
+ empty_vector, !RangeEquals( non_empty_vector )
</Original>
<Expanded>
- { } contains no true
+ { } not elements are { 1 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ non_empty_vector, !RangeEquals( empty_vector )
+ </Original>
+ <Expanded>
+ { 1 } not elements are { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ non_empty_array, RangeEquals( non_empty_array )
</Original>
<Expanded>
- { false, false, true, false, false } not contains no true
+ { 1 } elements are { 1 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, NoneTrue()
+ array_a, RangeEquals( array_a )
</Original>
<Expanded>
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ array_a, !RangeEquals( array_b )
</Original>
<Expanded>
- { true, true, true, true, true } not contains no true
+ { 1, 2, 3 } not elements are { 2, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_a, !RangeEquals( array_c )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal-sized, non-empty containers (with same first elements)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ vector_a, !RangeEquals( vector_b )
</Original>
<Expanded>
- { false, false, true, false, false } not contains no true
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, NoneTrue()
+ vector_a, RangeEquals( vector_a_plus_1, close_enough )
</Original>
<Expanded>
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } elements are { 2, 3, 4 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, NoneTrue()
+ vector_a, !RangeEquals( vector_b, close_enough )
</Original>
<Expanded>
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } not elements are { 3, 3, 4 }
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Ranges that need ADL begin/end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl1, RangeEquals( needs_adl2 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Check short-circuiting behaviour" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Check short-circuits on failure" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[0]
+ mocked1, !RangeEquals( arr )
</Original>
<Expanded>
- true
+ { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[1]
+ mocked1.m_derefed[0]
</Original>
<Expanded>
true
@@ -17436,7 +16712,7 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[2]
+ mocked1.m_derefed[1]
</Original>
<Expanded>
true
@@ -17444,37 +16720,37 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[3]
+ mocked1.m_derefed[2]
</Original>
<Expanded>
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[4]
+ !(mocked1.m_derefed[3])
</Original>
<Expanded>
- true
+ !false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Check short-circuiting behaviour" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All elements are checked on success" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, !NoneTrue()
+ mocked1, RangeEquals( arr )
</Original>
<Expanded>
- { false, false, true, true, true } not contains no true
+ { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[0]
+ mocked1.m_derefed[0]
</Original>
<Expanded>
true
@@ -17482,7 +16758,7 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[1]
+ mocked1.m_derefed[1]
</Original>
<Expanded>
true
@@ -17490,33 +16766,159 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[2]
+ mocked1.m_derefed[2]
</Original>
<Expanded>
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[3])
+ mocked1.m_derefed[3]
</Original>
<Expanded>
- !false
+ true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Usage of UnorderedRangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[4])
+ empty_vector, UnorderedRangeEquals( empty_vector )
</Original>
<Expanded>
- !false
+ { } unordered elements are { }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ empty_vector, !UnorderedRangeEquals( non_empty_vector )
+ </Original>
+ <Expanded>
+ { } not unordered elements are { 1 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ non_empty_vector, !UnorderedRangeEquals( empty_vector )
+ </Original>
+ <Expanded>
+ { 1 } not unordered elements are { }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ non_empty_array, UnorderedRangeEquals( non_empty_array )
+ </Original>
+ <Expanded>
+ { 1 } unordered elements are { 1 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_a, UnorderedRangeEquals( array_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_a, !UnorderedRangeEquals( array_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal-sized, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, !UnorderedRangeEquals( vector_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 10, 20 } unordered elements are { 11, 21, 2 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, !UnorderedRangeEquals( vector_b, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Ranges that need ADL begin/end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl1, UnorderedRangeEquals( needs_adl2 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Some with stdlib containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17576,7 +16978,7 @@ There is no extra whitespace here
{ {?}, {?}, {?} } has size == 3
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found size free function" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17587,7 +16989,7 @@ There is no extra whitespace here
{?} has size == 12
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type has size member" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17598,9 +17000,9 @@ There is no extra whitespace here
{?} has size == 13
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Use a custom approx" tags="[Approx][custom]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -17667,13 +17069,13 @@ There is no extra whitespace here
Approx( 1.23 ) != 1.25
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Variadic macros" tags="[sections][variadic]" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
<Section name="Section with one argument" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Vector Approx matcher" tags="[approx][matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Empty vector is roughly equal to an empty vector" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17685,7 +17087,7 @@ There is no extra whitespace here
{ } is approx: { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Vectors with elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="A vector is approx equal to itself" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17705,9 +17107,9 @@ There is no extra whitespace here
{ 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Vectors with elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Different length" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17719,9 +17121,9 @@ There is no extra whitespace here
{ 1.0, 2.0, 3.0 } not is approx: { 1.0, 2.0, 3.0, 4.0 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Vectors with elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Same length, different elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17757,11 +17159,11 @@ There is no extra whitespace here
{ 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 }
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Vector Approx matcher -- failing" tags="[.][approx][failing][matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Empty and non empty vectors are not approx equal" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17773,7 +17175,7 @@ There is no extra whitespace here
{ } is approx: { 1.0, 2.0 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Just different vectors" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17784,9 +17186,9 @@ There is no extra whitespace here
{ 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Vector matchers" tags="[matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Contains (element)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17814,7 +17216,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Contains: 2
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contains (vector)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17881,7 +17283,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Contains: { 1, 2 }
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contains (element), composed" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17892,7 +17294,7 @@ There is no extra whitespace here
{ 1, 2, 3 } ( Contains: 1 and Contains: 2 )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Equals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17943,7 +17345,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Equals: { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="UnorderedEquals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18002,9 +17404,9 @@ There is no extra whitespace here
{ 1, 3, 2 } UnorderedEquals: { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Vector matchers that fail" tags="[.][failing][matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Contains (element)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18024,7 +17426,7 @@ There is no extra whitespace here
{ } Contains: 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contains (vector)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18043,7 +17445,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Contains: { 1, 2, 4 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Equals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18078,7 +17480,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Equals: { }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="4" expectedFailures="0"/>
+ <OverallResults successes="0" failures="4" expectedFailures="0" skipped="false"/>
</Section>
<Section name="UnorderedEquals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18113,9 +17515,9 @@ There is no extra whitespace here
{ 3, 1 } UnorderedEquals: { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="4" expectedFailures="0"/>
+ <OverallResults successes="0" failures="4" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When checked exceptions are thrown they can be expected or unexpected" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18142,13 +17544,13 @@ There is no extra whitespace here
thisThrows()
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown directly they are always failures" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
unexpected exception
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown during a CHECK the test should continue" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18162,7 +17564,7 @@ There is no extra whitespace here
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown during a REQUIRE the test should abort fail" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18176,7 +17578,7 @@ There is no extra whitespace here
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown from functions they are always failures" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18190,31 +17592,31 @@ There is no extra whitespace here
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown from sections they are always failures" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Section name="section name" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
unexpected exception
</Exception>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown, but caught, they do not affect the test" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="X/level/0/a" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="X/level/0/b" tags="[fizz][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="X/level/1/a" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="X/level/1/b" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="XmlEncode" tags="[XML]" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Section name="normal string" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18226,7 +17628,7 @@ There is no extra whitespace here
"normal string" == "normal string"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="empty string" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18237,7 +17639,7 @@ There is no extra whitespace here
"" == ""
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with ampersand" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18248,7 +17650,7 @@ There is no extra whitespace here
"smith &amp; jones" == "smith &amp; jones"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with less-than" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18259,7 +17661,7 @@ There is no extra whitespace here
"smith &lt; jones" == "smith &lt; jones"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with greater-than" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18280,7 +17682,7 @@ There is no extra whitespace here
"smith ]]&gt; jones"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with quotes" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18303,7 +17705,7 @@ There is no extra whitespace here
"don't &quot;quote&quot; me on that"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with control char (1)" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18314,7 +17716,7 @@ There is no extra whitespace here
"[\x01]" == "[\x01]"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with control char (x7F)" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18325,9 +17727,9 @@ There is no extra whitespace here
"[\x7F]" == "[\x7F]"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="XmlWriter writes boolean attributes as true/false" tags="[XML][XmlWriter]" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18340,7 +17742,11 @@ There is no extra whitespace here
" ( contains: "attr1="true"" and contains: "attr2="false"" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="a succeeding test can still be skipped" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="analyse no analysis" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18447,7 +17853,7 @@ There is no extra whitespace here
0.0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="array<int, N> -> toString" tags="[array][containers][toString]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -18474,7 +17880,7 @@ There is no extra whitespace here
"{ 42, 250 }" == "{ 42, 250 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="benchmark function call" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Section name="without chronometer" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18518,7 +17924,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="with chronometer" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18561,9 +17967,9 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="boolean member" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -18574,7 +17980,7 @@ There is no extra whitespace here
0x<hex digits> != 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="checkedElse" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_ELSE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18593,7 +17999,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="checkedElse, failing" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECKED_ELSE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18612,7 +18018,7 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="checkedIf" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18631,7 +18037,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="checkedIf, failing" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18650,7 +18056,7 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="classify_outliers" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Section name="none" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18702,7 +18108,7 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="low severe" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18753,7 +18159,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="low mild" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18804,7 +18210,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="high mild" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18855,7 +18261,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="high severe" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18906,7 +18312,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="mixed" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18957,9 +18363,9 @@ There is no extra whitespace here
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="comparisons between const int variables" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -18994,7 +18400,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="comparisons between int variables" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -19029,7 +18435,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="convertToBits" tags="[conversion][floating-point]" filename="tests/<exe-name>/IntrospectiveTests/FloatingPoint.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/FloatingPoint.tests.cpp" >
@@ -19084,7 +18490,16 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="dynamic skipping works with generators" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ skipping because answer = 41
+ </Skip>
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ skipping because answer = 43
+ </Skip>
+ <OverallResult success="true" skips="2"/>
</TestCase>
<TestCase name="empty tags are not allowed" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -19095,7 +18510,7 @@ There is no extra whitespace here
Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="erfc_inv" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19122,7 +18537,7 @@ There is no extra whitespace here
1.3859038243 == Approx( 1.3859038243 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="estimate_clock_resolution" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19141,53 +18556,83 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="even more nested SECTION tests" tags="[sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="c" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="d (leaf)" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="c" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="e (leaf)" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="f (leaf)" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="failed assertions before SKIP cause test case to fail" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Original>
+ 3 == 4
+ </Original>
+ <Expanded>
+ 3 == 4
+ </Expanded>
+ </Expression>
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="1"/>
+ </TestCase>
+ <TestCase name="failing for some generator values causes entire test case to fail" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Failure filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <Failure filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="2"/>
+ </TestCase>
+ <TestCase name="failing in some unskipped sections causes entire test case to fail" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <Section name="not skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Failure filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="first tag" tags="[tag1]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="has printf" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
loose text artifact
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="is_unary_function" tags="[clara][compilation]" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="just failure" tags="[.][fail][isolated info][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Previous info should not be seen
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="just failure after unscoped info" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
previous unscoped info SHOULD not be seen
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="just info" tags="[info][isolated info][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="just unscoped info" tags="[info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="long long" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19200,7 +18645,7 @@ loose text artifact
9223372036854775807 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="looped SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="b is currently: 0" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19212,7 +18657,7 @@ loose text artifact
0 > 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 1" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19223,7 +18668,7 @@ loose text artifact
1 > 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 2" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19234,7 +18679,7 @@ loose text artifact
2 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 3" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19245,7 +18690,7 @@ loose text artifact
3 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 4" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19256,7 +18701,7 @@ loose text artifact
4 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 5" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19267,7 +18712,7 @@ loose text artifact
5 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 6" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19278,7 +18723,7 @@ loose text artifact
6 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 7" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19289,7 +18734,7 @@ loose text artifact
7 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 8" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19300,7 +18745,7 @@ loose text artifact
8 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 9" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19311,12 +18756,12 @@ loose text artifact
9 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="looped tests" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[0] (1) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19327,7 +18772,7 @@ loose text artifact
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[1] (1) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19338,7 +18783,7 @@ loose text artifact
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[2] (2) is even
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19349,7 +18794,7 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[3] (3) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19360,7 +18805,7 @@ loose text artifact
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[4] (5) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19371,7 +18816,7 @@ loose text artifact
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[5] (8) is even
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19382,7 +18827,7 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[6] (13) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19393,7 +18838,7 @@ loose text artifact
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[7] (21) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19404,7 +18849,7 @@ loose text artifact
1 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="makeStream recognizes %debug stream name" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -19415,7 +18860,7 @@ loose text artifact
Catch::makeStream( "%debug" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="make_unique reimplementation" tags="[internals][unique-ptr]" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Section name="From lvalue copies" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -19427,7 +18872,7 @@ loose text artifact
!false
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From rvalue moves" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -19438,7 +18883,7 @@ loose text artifact
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Variadic constructor" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -19449,9 +18894,9 @@ loose text artifact
{?} == {?}
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="mean" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19462,7 +18907,7 @@ loose text artifact
19.0 == 19.0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="measure" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19529,28 +18974,28 @@ loose text artifact
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="mix info, unscoped info and warning" tags="[info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
info
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
unscoped info
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
and warn may mix
</Warning>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
info
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
unscoped info
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
they are not cleared after warnings
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="more nested SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19563,9 +19008,9 @@ loose text artifact
1 == 2
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="not equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19577,9 +19022,9 @@ loose text artifact
1 != 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="less than" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19591,11 +19036,11 @@ loose text artifact
1 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="nested SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19624,11 +19069,39 @@ loose text artifact
1 != 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="nested sections can be skipped dynamically at runtime" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="A" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="B" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="B1" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="B" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="B2" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <Section name="B" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="false" skips="1">
+ <StdOut>
+a!
+b1!
+!
+ </StdOut>
+ </OverallResult>
</TestCase>
<TestCase name="non streamable - with conv. op" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19639,7 +19112,7 @@ loose text artifact
"7" == "7"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="non-copyable objects" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19650,7 +19123,7 @@ loose text artifact
{?} == {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="normal_cdf" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19693,7 +19166,7 @@ loose text artifact
0.088096521 == Approx( 0.088096521 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="normal_quantile" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19720,13 +19193,13 @@ loose text artifact
-1.9599639845 == Approx( -1.9599639845 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="not allowed" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="not prints unscoped info from previous failures" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY be seen only for the FIRST assertion IF info is printed for passing assertions
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19737,7 +19210,7 @@ loose text artifact
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY be seen only for the SECOND assertion IF info is printed for passing assertions
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19748,7 +19221,7 @@ loose text artifact
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD be seen
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19759,7 +19232,7 @@ loose text artifact
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="null strings" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19778,7 +19251,7 @@ loose text artifact
{null string} == {null string}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="null_ptr" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19789,7 +19262,7 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="pair<pair<int,const char *,pair<std::string,int> > -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -19802,7 +19275,7 @@ loose text artifact
"{ { 42, "Arthur" }, { "Ford", 24 } }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="parseEnums" tags="[enums][Strings]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Section name="No enums" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -19814,7 +19287,7 @@ loose text artifact
{ } Equals: { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="One enum value" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -19841,7 +19314,7 @@ loose text artifact
{ Value1 } Equals: { Value1 }
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Multiple enum values" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -19868,9 +19341,9 @@ loose text artifact
{ Value1, Value2, Value3 } Equals: { Value1, Value2, Value3 }
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="pointer to class" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19881,10 +19354,10 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="print unscoped info if passing unscoped info is printed" tags="[info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY be seen IF info is printed for passing assertions
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19895,13 +19368,13 @@ loose text artifact
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="prints unscoped info on failure" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD be seen
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD also be seen
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19912,10 +19385,10 @@ loose text artifact
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="prints unscoped info only for the first assertion" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD be seen only ONCE
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19934,7 +19407,7 @@ loose text artifact
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY also be seen only ONCE IF info is printed for passing assertions
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19953,7 +19426,7 @@ loose text artifact
true
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="random SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19973,7 +19446,7 @@ loose text artifact
2 != 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="not equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19984,9 +19457,9 @@ loose text artifact
1 != 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="replaceInPlace" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Section name="replace single char" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20006,7 +19479,7 @@ loose text artifact
"azcdefcg" == "azcdefcg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace two chars" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20025,7 +19498,7 @@ loose text artifact
"abzdefzg" == "abzdefzg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace first char" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20044,7 +19517,7 @@ loose text artifact
"zbcdefcg" == "zbcdefcg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace last char" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20063,7 +19536,7 @@ loose text artifact
"abcdefcz" == "abcdefcz"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace all chars" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20082,7 +19555,7 @@ loose text artifact
"replaced" == "replaced"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace no chars" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20101,7 +19574,7 @@ loose text artifact
"abcdefcg" == "abcdefcg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="escape '" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20120,9 +19593,9 @@ loose text artifact
"didn|'t" == "didn|'t"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="request an unknown %-starting stream fails" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -20133,7 +19606,7 @@ loose text artifact
Catch::makeStream( "%somestream" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="resolution" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -20216,7 +19689,7 @@ loose text artifact
1000.0 == 1000 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="run_for_at_least, chronometer" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -20307,7 +19780,7 @@ loose text artifact
128 >= 100
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="run_for_at_least, int" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -20398,13 +19871,26 @@ loose text artifact
128 >= 100
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="second tag" tags="[tag2]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
+ </TestCase>
+ <TestCase name="sections can be skipped dynamically at runtime" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="not skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <Section name="also not skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="send a single char to INFO" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
3
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20415,13 +19901,13 @@ loose text artifact
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="sends information to INFO" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
hi
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 7
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -20432,7 +19918,7 @@ loose text artifact
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="shortened hide tags are split apart" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -20443,7 +19929,13 @@ loose text artifact
{ {?}, {?} } ( Contains: {?} and Contains: {?} )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="skipped tests can optionally provide a reason" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ skipping because answer = 43
+ </Skip>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="splitString" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20470,19 +19962,19 @@ loose text artifact
{ abc, def } Equals: { abc, def }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stacks unscoped info in loops" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Count 1 to 3...
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
3
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -20493,16 +19985,16 @@ loose text artifact
false
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Count 4 to 6...
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
6
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -20513,7 +20005,7 @@ loose text artifact
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="startsWith" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20540,7 +20032,7 @@ loose text artifact
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::map is convertible string" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="empty" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20552,7 +20044,7 @@ loose text artifact
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="single item" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20563,7 +20055,7 @@ loose text artifact
"{ { "one", 1 } }" == "{ { "one", 1 } }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="several items" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20576,9 +20068,9 @@ loose text artifact
"{ { "abc", 1 }, { "def", 2 }, { "ghi", 3 } }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::pair<int,const std::string> -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -20589,7 +20081,7 @@ loose text artifact
"{ 34, "xyzzy" }" == "{ 34, "xyzzy" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::pair<int,std::string> -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -20600,7 +20092,7 @@ loose text artifact
"{ 34, "xyzzy" }" == "{ 34, "xyzzy" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::set is convertible string" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="empty" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20612,7 +20104,7 @@ loose text artifact
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="single item" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20623,7 +20115,7 @@ loose text artifact
"{ "one" }" == "{ "one" }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="several items" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20636,9 +20128,9 @@ loose text artifact
"{ "abc", "def", "ghi" }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::vector<std::pair<std::string,int> > -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -20651,7 +20143,7 @@ loose text artifact
"{ { "green", 55 } }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stdout and stderr streams have %-starting name" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -20670,7 +20162,7 @@ loose text artifact
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify ranges" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20709,7 +20201,7 @@ loose text artifact
"{?}" == "{?}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_maker )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20722,7 +20214,7 @@ loose text artifact
"StringMaker<has_maker>"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_maker_and_operator )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20735,7 +20227,7 @@ loose text artifact
"StringMaker<has_maker_and_operator>"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_neither )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20746,7 +20238,7 @@ loose text artifact
"{?}" == "{?}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_operator )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20759,7 +20251,7 @@ loose text artifact
"operator<<( has_operator )"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_template_operator )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20772,7 +20264,7 @@ loose text artifact
"operator<<( has_template_operator )"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( vectors<has_maker> )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20785,7 +20277,7 @@ loose text artifact
"{ StringMaker<has_maker> }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( vectors<has_maker_and_operator> )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20798,7 +20290,7 @@ loose text artifact
"{ StringMaker<has_maker_and_operator> }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( vectors<has_operator> )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20811,7 +20303,7 @@ loose text artifact
"{ operator<<( has_operator ) }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="strlen3" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -20846,7 +20338,7 @@ loose text artifact
4 == 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tables" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -20881,7 +20373,7 @@ loose text artifact
6 == 6
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tags with dots in later positions are not parsed as hidden" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -20900,13 +20392,17 @@ loose text artifact
magic.tag == magic.tag
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="tests can be skipped dynamically at runtime" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="thrown std::strings are translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
Why would you throw a std::string?
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="toString on const wchar_t const pointer returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20917,7 +20413,7 @@ loose text artifact
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString on const wchar_t pointer returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20928,7 +20424,7 @@ loose text artifact
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString on wchar_t const pointer returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20939,7 +20435,7 @@ loose text artifact
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString on wchar_t returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20950,7 +20446,7 @@ loose text artifact
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum class w/operator<<)" tags="[enum][enumClass][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -20979,7 +20475,7 @@ loose text artifact
"Unknown enum value 10"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum class)" tags="[enum][enumClass][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -20998,7 +20494,7 @@ loose text artifact
"1" == "1"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum w/operator<<)" tags="[enum][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -21017,7 +20513,7 @@ loose text artifact
"E2{1}" == "E2{1}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum)" tags="[enum][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -21036,7 +20532,7 @@ loose text artifact
"1" == "1"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21055,7 +20551,7 @@ loose text artifact
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<float,int>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21074,7 +20570,7 @@ loose text artifact
"{ 1.2f, 0 }" == "{ 1.2f, 0 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<int>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21085,7 +20581,7 @@ loose text artifact
"{ 0 }" == "{ 0 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<string,string>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21098,7 +20594,7 @@ loose text artifact
"{ "hello", "world" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<tuple<int>,tuple<>,float>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21111,7 +20607,7 @@ loose text artifact
"{ { 42 }, { }, 1.2f }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="uniform samples" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -21146,7 +20642,7 @@ loose text artifact
0.95 == 0.95
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="unique_ptr reimplementation: basic functionality" tags="[internals][unique-ptr]" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Section name="Default constructed unique_ptr is empty" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21166,7 +20662,7 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take ownership of allocation" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21210,9 +20706,9 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take ownership of allocation" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21264,9 +20760,9 @@ loose text artifact
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Release releases ownership" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21285,7 +20781,7 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Move constructor" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21312,7 +20808,7 @@ loose text artifact
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Move assignment" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21339,7 +20835,7 @@ loose text artifact
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="free swap" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21358,9 +20854,9 @@ loose text artifact
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vec<vec<string,alloc>> -> toString" tags="[toString][vector,allocator]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21381,7 +20877,7 @@ loose text artifact
"{ { "hello" }, { "world" } }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<bool> -> toString" tags="[containers][toString][vector]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21408,7 +20904,7 @@ loose text artifact
"{ true, false }" == "{ true, false }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<int,allocator> -> toString" tags="[toString][vector,allocator]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21435,7 +20931,7 @@ loose text artifact
"{ 42, 250 }" == "{ 42, 250 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<int> -> toString" tags="[toString][vector]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21462,7 +20958,7 @@ loose text artifact
"{ 42, 250 }" == "{ 42, 250 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<string> -> toString" tags="[toString][vector]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21491,7 +20987,7 @@ loose text artifact
"{ "hello", "world" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vectors can be sized and resized" tags="[vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -21527,7 +21023,7 @@ loose text artifact
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -21571,9 +21067,9 @@ loose text artifact
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -21608,7 +21104,7 @@ loose text artifact
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -21643,9 +21139,9 @@ loose text artifact
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="warmup" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -21664,7 +21160,7 @@ loose text artifact
310016000 ns > 100 ms
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="weighted_average_quantile" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -21691,17 +21187,17 @@ loose text artifact
23.0 == 23.0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="xmlentitycheck" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="embedded xml: <test>it should be possible to embed xml characters, such as <, " or &, or even whole <xml>documents</xml> within an attribute</test>" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="encoded chars: these should all be encoded: &&&"""<<<&"<<&"" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <OverallResults successes="2129" failures="143" expectedFailures="27"/>
- <OverallResultsCases successes="304" failures="83" expectedFailures="7"/>
+ <OverallResults successes="2048" failures="145" expectedFailures="32" skips="12"/>
+ <OverallResultsCases successes="308" failures="84" expectedFailures="11" skips="6"/>
</Catch2TestRun>
diff --git a/packages/Catch2/tests/SelfTest/Baselines/xml.sw.multi.approved.txt b/packages/Catch2/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
index 7a88f7de7f811b51093b4fdfa0ca12ece47a82fc..41dc8cb31522471f771534ff2fb0a878a870dcad 100644
--- a/packages/Catch2/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
+++ b/packages/Catch2/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
-<Catch2TestRun name="<exe-name>" rng-seed="1" catch2-version="<version>" filters="~[!nonportable]~[!benchmark]~[approvals] *">
+<Catch2TestRun name="<exe-name>" rng-seed="1" xml-format-version="3" catch2-version="<version>" filters=""*" ~[!nonportable] ~[!benchmark] ~[approvals]">
<TestCase name="# A test name that starts with a #" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1027: Bitfields can be captured" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -20,7 +20,7 @@
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1147" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -71,16 +71,16 @@
{?} >= {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1175 - Hidden Test" tags="[.]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1238" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
uarr := "123"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
sarr := "456"
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -91,10 +91,10 @@
0 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
uarr := "123"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
sarr := "456"
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -105,16 +105,16 @@
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1245" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1319: Sections can have description (even if it is not saved" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Section name="SectionName" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1403" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -125,24 +125,24 @@
[1403 helper] == [1403 helper]
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1455 - INFO and WARN can start with a linebreak" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This info message starts with a linebreak
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This warning message starts with a linebreak
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="#1514: stderr/stdout is not captured in tests aborted by an exception" tags="[.][output-capture][regression]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
1514
</Failure>
- <OverallResult success="false">
+ <OverallResult success="false" skips="0">
<StdOut>
This would not be caught previously
</StdOut>
@@ -160,10 +160,10 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="#1905 -- test spec parser properly clears internal state between compound tests" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <TestCase name="#1905 -- test spec parser properly clears internal state between compound tests" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase("spec . char"))
</Original>
@@ -171,7 +171,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase("spec , char"))
</Original>
@@ -179,7 +179,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
!(spec.matches(*fakeTestCase(R"(spec \, char)")))
</Original>
@@ -187,11 +187,11 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="#1912 -- test spec parser handles escaping" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="Various parentheses" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <TestCase name="#1912 -- test spec parser handles escaping" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Section name="Various parentheses" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase(R"(spec {a} char)"))
</Original>
@@ -199,7 +199,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase(R"(spec [a] char)"))
</Original>
@@ -207,7 +207,7 @@ Nor would this
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
!(spec.matches(*fakeTestCase("differs but has similar tag", "[a]")))
</Original>
@@ -215,10 +215,10 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="backslash in test name" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="backslash in test name" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpec.tests.cpp" >
<Original>
spec.matches(*fakeTestCase(R"(spec \ char)"))
</Original>
@@ -226,9 +226,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1913 - GENERATE inside a for loop should not keep recreating the generator" tags="[generators][regression]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -247,7 +247,7 @@ Nor would this
6 < 7
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1913 - GENERATEs can share a line" tags="[generators][regression]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -282,11 +282,11 @@ Nor would this
2 != 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - GENERATE after a section" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -297,7 +297,7 @@ Nor would this
1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -308,7 +308,7 @@ Nor would this
2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -319,9 +319,9 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - Section followed by flat generate" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -333,7 +333,7 @@ Nor would this
1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -351,7 +351,7 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - flat generate" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -378,100 +378,100 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - mixed sections and generates" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
<Section name="A" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
<Section name="B" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
i := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
j := 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
k := 6
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1938 - nested generate" tags="[.][generators][regression]" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -618,16 +618,16 @@ Nor would this
3
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1954 - 7 arg template test case sig compiles - 1, 1, 1, 1, 1, 0, 0" tags="[.][compilation][regression]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1954 - 7 arg template test case sig compiles - 5, 1, 1, 1, 1, 0, 0" tags="[.][compilation][regression]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#1954 - 7 arg template test case sig compiles - 5, 3, 1, 1, 1, 0, 0" tags="[.][compilation][regression]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#2152 - ULP checks between differently signed values were wrong - double" tags="[floating-point][matchers][ulp]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -646,7 +646,7 @@ Nor would this
0.0 not is within 1 ULPs of -4.9406564584124654e-324 ([-9.8813129168249309e-324, -0.0000000000000000e+00])
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#2152 - ULP checks between differently signed values were wrong - float" tags="[floating-point][matchers][ulp]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -665,20 +665,26 @@ Nor would this
0.0f not is within 1 ULPs of -1.40129846e-45f ([-2.80259693e-45, -0.00000000e+00])
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="#2615 - Throwing in constructor generator fails test case but does not abort" tags="[!shouldfail]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
+ <Exception filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
+ failure to init
+ </Exception>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#748 - captures with unexpected exceptions" tags="[!shouldfail][!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Section name="outside assertions" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
answer := 42
</Info>
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
expected exception
</Exception>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="inside REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
answer := 42
</Info>
<Expression success="false" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -692,10 +698,10 @@ Nor would this
expected exception
</Exception>
</Expression>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="inside REQUIRE_THROWS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
answer := 42
</Info>
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -706,9 +712,9 @@ Nor would this
thisThrows()
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#809" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -719,7 +725,7 @@ Nor would this
42 == {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#833" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -778,7 +784,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#835 -- errno should not be touched by Catch2" tags="[!shouldfail][.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -797,10 +803,10 @@ Nor would this
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#872" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
dummy := 0
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -811,25 +817,25 @@ Nor would this
{?} == 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="#961 -- Dynamically created sections should all be reported" tags="[.]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="Looped section 0" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 1" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 2" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 3" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Looped section 4" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="'Not' checks that should fail" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -896,7 +902,7 @@ Nor would this
!(1 == 1)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="'Not' checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -963,7 +969,7 @@ Nor would this
!(1 == 2)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="(unimplemented) static bools can be evaluated" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Section name="compare to true" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -983,7 +989,7 @@ Nor would this
true == true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="compare to false" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1002,7 +1008,7 @@ Nor would this
false == false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="negation" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1013,7 +1019,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="double negation" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1024,7 +1030,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="direct" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -1043,9 +1049,9 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="3x3x3 ints" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -1696,7 +1702,7 @@ Nor would this
3 < 9
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A METHOD_AS_TEST_CASE based test run that fails" tags="[.][class][failing]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1707,7 +1713,7 @@ Nor would this
"hello" == "world"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A METHOD_AS_TEST_CASE based test run that succeeds" tags="[class]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1718,7 +1724,7 @@ Nor would this
"hello" == "hello"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<float>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1729,7 +1735,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - Template_Foo<int>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1740,7 +1746,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<float>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1751,7 +1757,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that fails - std::vector<int>" tags="[.][class][failing][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1762,7 +1768,7 @@ Nor would this
0 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<float>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1773,7 +1779,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - Template_Foo<int>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1784,7 +1790,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<float>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1795,7 +1801,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test run that succeeds - std::vector<int>" tags="[class][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1806,7 +1812,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<float, 6>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1817,7 +1823,7 @@ Nor would this
6 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - Template_Foo_2<int, 2>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1828,7 +1834,7 @@ Nor would this
2 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<float, 6>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1839,7 +1845,7 @@ Nor would this
6 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that fails - std::array<int, 2>" tags="[.][class][failing][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1850,7 +1856,7 @@ Nor would this
2 < 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<float,6>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1861,7 +1867,7 @@ Nor would this
6 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - Template_Foo_2<int,2>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1872,7 +1878,7 @@ Nor would this
2 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<float,6>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1883,7 +1889,7 @@ Nor would this
6 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds - std::array<int,2>" tags="[class][nttp][product][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1894,7 +1900,7 @@ Nor would this
2 >= 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - double" tags="[.][class][failing][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1905,7 +1911,7 @@ Nor would this
1.0 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - float" tags="[.][class][failing][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1916,7 +1922,7 @@ Nor would this
1.0f == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that fails - int" tags="[.][class][failing][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1927,7 +1933,7 @@ Nor would this
1 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - double" tags="[class][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1938,7 +1944,7 @@ Nor would this
1.0 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float" tags="[class][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1949,7 +1955,7 @@ Nor would this
1.0f == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - int" tags="[class][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1960,7 +1966,7 @@ Nor would this
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 1" tags="[.][class][failing][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1971,7 +1977,7 @@ Nor would this
1 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 3" tags="[.][class][failing][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1982,7 +1988,7 @@ Nor would this
3 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that fails - 6" tags="[.][class][failing][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -1993,7 +1999,7 @@ Nor would this
6 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 1" tags="[class][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2004,7 +2010,7 @@ Nor would this
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 3" tags="[class][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2015,7 +2021,7 @@ Nor would this
3 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds - 6" tags="[class][nttp][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2026,7 +2032,7 @@ Nor would this
6 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A TEST_CASE_METHOD based test run that fails" tags="[.][class][failing]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2037,7 +2043,7 @@ Nor would this
1 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A TEST_CASE_METHOD based test run that succeeds" tags="[class]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -2048,7 +2054,7 @@ Nor would this
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - Foo<float>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2059,7 +2065,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - Foo<int>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2070,7 +2076,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - std::vector<float>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2081,7 +2087,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case - std::vector<int>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2092,7 +2098,7 @@ Nor would this
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - Bar<float, 42>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2103,7 +2109,7 @@ Nor would this
42 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - Bar<int, 9>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2114,7 +2120,7 @@ Nor would this
9 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - std::array<float, 42>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2125,7 +2131,7 @@ Nor would this
42 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A Template product test case with array signature - std::array<int, 9>" tags="[nttp][product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -2136,7 +2142,7 @@ Nor would this
9 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A comparison that uses literals instead of the normal constructor" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2187,19 +2193,19 @@ Nor would this
1.23 == Approx( 1.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="A couple of nested sections followed by a failure" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="Outer" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="Inner" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Failure filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
to infinity and beyond
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="A failing expression with a non streamable type is still captured" tags="[.][failing][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -2218,7 +2224,7 @@ Nor would this
{?} == {?}
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Absolute margin" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2269,10 +2275,10 @@ Nor would this
100.3 == Approx( 100.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="An empty test with no assertions" tags="[empty]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="An expression with side-effects should only be evaluated once" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -2291,7 +2297,7 @@ Nor would this
8 == 8
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="An unchecked exception reports the line of the last assertion" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -2313,10 +2319,10 @@ Nor would this
unexpected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Anonymous test case 1" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approx setters validate their arguments" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2375,7 +2381,7 @@ Nor would this
Approx(0).epsilon(1.0001), std::domain_error
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approx with exactly-representable margin" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2418,7 +2424,7 @@ Nor would this
245.5f == Approx( 245.25 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate PI" tags="[Approx][PI]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2437,7 +2443,7 @@ Nor would this
3.1428571429 != Approx( 3.141 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with different epsilons" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2456,7 +2462,7 @@ Nor would this
1.23 == Approx( 1.231 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with floats" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2475,7 +2481,7 @@ Nor would this
0.0f == Approx( 0.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with ints" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2494,7 +2500,7 @@ Nor would this
0 == Approx( 0.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Approximate comparisons with mixed numeric types" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -2537,7 +2543,7 @@ Nor would this
1.234 == Approx( 1.2339999676 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Arbitrary predicate matcher" tags="[generic][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Function pointer" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -2557,7 +2563,7 @@ Nor would this
1 not matches predicate: "always false"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Lambdas + different type" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -2576,9 +2582,9 @@ Nor would this
"This wouldn't pass" not matches undescribed predicate
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Assertion macros support bit operators and bool conversions" tags="[bitops][compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -2621,7 +2627,7 @@ Nor would this
!(Val: 1 ^ Val: 1)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Assertions then sections" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -2650,9 +2656,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Original>
@@ -2680,11 +2686,11 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Basic use of the Contains range matcher" tags="[contains][matchers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Different argument ranges, same element type, default comparison" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2712,7 +2718,7 @@ Nor would this
{ 4, 5, 6 } not contains element 1
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different argument ranges, same element type, custom comparison" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2739,7 +2745,7 @@ Nor would this
{ 4, 5, 6 } not contains element 0
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different element type, custom comparisons" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2750,7 +2756,7 @@ Nor would this
{ "abc", "abcd", "abcde" } contains element 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Can handle type that requires ADL-found free function begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2769,7 +2775,7 @@ Nor would this
{ 1, 2, 3, 4, 5 } not contains element 8
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Initialization with move only types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2788,7 +2794,7 @@ Nor would this
{ 1, 2, 3 } not contains element 9
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Matching using matcher" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2799,9 +2805,9 @@ Nor would this
{ 1.0, 2.0, 3.0, 0.0 } contains element matching is within 0.5 of 0.5
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Basic use of the Empty range matcher" tags="[empty][matchers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Simple, std-provided containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2853,7 +2859,7 @@ Nor would this
{ } is empty
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type with empty" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2864,7 +2870,7 @@ Nor would this
{?} not is empty
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found empty free function" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -2875,97 +2881,97 @@ Nor would this
{?} is empty
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CAPTURE can deal with complex expressions" tags="[capture][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
b := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
c := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a + b := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a+b := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
c > b := true
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
a == 1 := true
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CAPTURE can deal with complex expressions involving commas" tags="[capture][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
std::vector<int>{1, 2, 3}[0, 1, 2] := 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
std::vector<int>{1, 2, 3}[(0, 1)] := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
std::vector<int>{1, 2, 3}[0] := 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(helper_1436<int, int>{12, -12}) := { 12, -12 }
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(helper_1436<int, int>(-12, 12)) := { -12, 12 }
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(1, 2) := 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
(2, 3) := 3
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CAPTURE parses string and character constants" tags="[capture][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
("comma, in string", "escaped, \", ") := "escaped, ", "
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
"single quote in string,'," := "single quote in string,',"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
"some escapes, \\,\\\\" := "some escapes, \,\\"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
"some, ), unmatched, } prenheses {[<" := "some, ), unmatched, } prenheses {[<"
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'"' := '"'
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'\'' := '''
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
',' := ','
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'}' := '}'
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
')' := ')'
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'(' := '('
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
'{' := '{'
</Info>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Capture and info messages" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Capture should stringify like assertions" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
i := 2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -2976,10 +2982,10 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Info should NOT stringify the way assertions do" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -2990,9 +2996,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CaseInsensitiveEqualsTo is case insensitive" tags="[comparisons][string-case]" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Section name="Degenerate cases" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3012,7 +3018,7 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Plain comparisons" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3063,9 +3069,9 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="CaseInsensitiveLess is case insensitive" tags="[comparisons][string-case]" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Section name="Degenerate cases" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3093,7 +3099,7 @@ Nor would this
!false
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Plain comparisons" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Details.tests.cpp" >
@@ -3128,9 +3134,9 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Character pretty printing" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Specifically escaped" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -3166,7 +3172,7 @@ Nor would this
'\f' == '\f'
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="General chars" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -3209,7 +3215,7 @@ Nor would this
'Z' == 'Z'
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Low ASCII" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -3252,9 +3258,9 @@ Nor would this
5 == 5
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Clara::Arg supports single-arg parse the way Opt does" tags="[arg][clara][compilation]" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
@@ -3273,7 +3279,7 @@ Nor would this
"foo" == "foo"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Clara::Opt supports accept-many lambdas" tags="[clara][opt]" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
<Section name="Parsing fails on multiple options without accept_many" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
@@ -3285,7 +3291,7 @@ Nor would this
!{?}
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Parsing succeeds on multiple options with accept_many" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
@@ -3304,9 +3310,9 @@ Nor would this
{ "aaa", "bbb" } == { "aaa", "bbb" }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="ColourGuard behaviour" tags="[console-colours]" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
<Section name="ColourGuard is disengaged by default" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
@@ -3318,7 +3324,7 @@ Nor would this
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ColourGuard is engaged by op<<" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
@@ -3341,7 +3347,7 @@ Using code: 0
"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ColourGuard can be engaged explicitly" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/ColourImpl.tests.cpp" >
@@ -3364,9 +3370,9 @@ C
"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining MatchAllOfGeneric does not nest" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3393,7 +3399,7 @@ C
1 ( equals: (int) 1 or (string) "1" and equals: (long long) 1 and equals: (T) 1 and equals: true )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining MatchAnyOfGeneric does not nest" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3420,7 +3426,7 @@ C
1 ( equals: (int) 1 or (string) "1" or equals: (long long) 1 or equals: (T) 1 or equals: true )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining MatchNotOfGeneric does not nest" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3455,10 +3461,10 @@ C
1 equals: (int) 1 or (string) "1"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining concrete matchers does not use templated matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining only templated matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3485,7 +3491,7 @@ C
1 ( equals: (int) 1 or (string) "1" or not equals: (long long) 1 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining templated and concrete matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3544,7 +3550,7 @@ C
"foobar" ( ( starts with: "foo" and ends with: "bar" ) or Equals: { 'o', 'o', 'f', 'b', 'a', 'r' } )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Combining templated matchers" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -3555,7 +3561,7 @@ C
{ 1, 2, 3 } ( Equals: { 1, 2, 3 } or Equals: { 0, 1, 2 } or Equals: { 4, 5, 6 } )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Commas in various macros are allowed" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -3654,7 +3660,7 @@ C
{ 1, 2 } == { 1, 2 }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparing function pointers" tags="[function pointer][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -3673,7 +3679,7 @@ C
0x<hex digits> == 0x<hex digits>
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparison ops" tags="[rng]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -3708,7 +3714,7 @@ C
!({?} != {?})
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparison with explicitly convertible types" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -3807,7 +3813,7 @@ C
Approx( 11.0 ) >= StrongDoubleTypedef(10)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparisons between ints where one side is computed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -3818,7 +3824,7 @@ C
54 == 54
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparisons between unsigned ints and negative signed ints match c++ standard behaviour" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -3869,7 +3875,7 @@ C
-2147483648 > 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Comparisons with int literals don't warn when mixing signed/ unsigned" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -3976,7 +3982,7 @@ C
4294967295 (0x<hex digits>) > 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Composed generic matchers shortcircuit" tags="[composed][generic][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="MatchAllOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4004,7 +4010,7 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="MatchAnyOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4031,9 +4037,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Composed matchers shortcircuit" tags="[composed][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="MatchAllOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4061,7 +4067,7 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="MatchAnyOf" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4088,9 +4094,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Contains string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4109,7 +4115,7 @@ C
"this string contains 'abc' as a substring" contains: "STRING"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Copy and then generate a range" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4121,7 +4127,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4132,7 +4138,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4143,7 +4149,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4154,7 +4160,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4165,7 +4171,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from var and iterators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4176,7 +4182,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4187,7 +4193,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4198,7 +4204,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4209,7 +4215,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4220,7 +4226,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4231,7 +4237,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From a temporary container" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4242,7 +4248,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Final validation" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -4261,9 +4267,9 @@ C
6 == 6
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Cout stream properly declares it writes to stdout" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -4274,7 +4280,7 @@ C
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Custom exceptions can be translated when testing for nothrow" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4288,7 +4294,7 @@ C
custom exception - not std
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Custom exceptions can be translated when testing for throwing as something else" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4302,13 +4308,13 @@ C
custom exception - not std
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Custom std-exceptions can be custom translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
custom std exception
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Default scale is invisible to comparison" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -4327,7 +4333,7 @@ C
0.00001 != Approx( 0.0000001 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Directly creating an EnumInfo" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -4356,7 +4362,13 @@ C
"{** unexpected enum value **}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Empty generators can SKIP in constructor" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ This generator is empty
+ </Skip>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="Empty stream name opens cout stream" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -4367,18 +4379,7 @@ C
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Empty tag is not allowed" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
- <Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
- <Original>
- Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
- </Original>
- <Expanded>
- Catch::TestCaseInfo( "", { "fake test name", "[]" }, dummySourceLineInfo )
- </Expanded>
- </Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="EndsWith string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4397,7 +4398,7 @@ C
"this string contains 'abc' as a substring" ends with: "this" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Enums can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -4442,7 +4443,7 @@ C
"Value2" == "Value2"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -4461,7 +4462,7 @@ C
"Blue" == "Blue"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Epsilon only applies to Approx's value" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -4472,7 +4473,7 @@ C
101.01 != Approx( 100.0 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equality checks that should fail" tags="[!mayfail][.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -4579,7 +4580,7 @@ C
1.3 == Approx( 1.301 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equality checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -4638,7 +4639,7 @@ C
1.3 == Approx( 1.3 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equals" tags="[matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4657,7 +4658,7 @@ C
"this string contains 'abc' as a substring" equals: "this string contains 'abc' as a substring" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Equals string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4676,7 +4677,7 @@ C
"this string contains 'abc' as a substring" equals: "something else" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Exception as a value (e.g. in REQUIRE_THROWS_MATCHES) can be stringified" tags="[exception][toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -4707,7 +4708,7 @@ C
"StringMakerException"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Exception matchers that fail" tags="[!throws][.][exceptions][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="No exception" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4727,7 +4728,7 @@ C
doesNotThrow(), SpecialException, ExceptionMatcher{ 1 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type mismatch" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4752,7 +4753,7 @@ C
Unknown exception
</Exception>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contents are wrong" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4771,9 +4772,9 @@ C
SpecialException::what special exception has value of 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Exception matchers that succeed" tags="[!throws][exceptions][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4792,7 +4793,42 @@ C
SpecialException::what special exception has value of 2
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Exception message can be matched" tags="[!throws][exceptions][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsDerivedException(), DerivedException, MessageMatches( StartsWith( "Derived" ) )
+ </Original>
+ <Expanded>
+ DerivedException::what matches "starts with: "Derived""
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsDerivedException(), DerivedException, MessageMatches( EndsWith( "::what" ) )
+ </Original>
+ <Expanded>
+ DerivedException::what matches "ends with: "::what""
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsDerivedException(), DerivedException, MessageMatches( !StartsWith( "::what" ) )
+ </Original>
+ <Expanded>
+ DerivedException::what matches "not starts with: "::what""
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ throwsSpecialException( 2 ), SpecialException, MessageMatches( StartsWith( "Special" ) )
+ </Original>
+ <Expanded>
+ SpecialException::what matches "starts with: "Special""
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Exception messages can be tested for" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Section name="exact match" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4804,7 +4840,7 @@ C
"expected exception" equals: "expected exception"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="different case" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4815,7 +4851,7 @@ C
"expected exception" equals: "expected exception" (case insensitive)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="wildcarded" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4850,9 +4886,9 @@ C
"expected exception" contains: "except" (case insensitive)
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Exceptions matchers" tags="[!throws][exceptions][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_MATCHES" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -4887,7 +4923,7 @@ C
SpecialException::what exception message matches "SpecialException::what"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Expected exceptions that don't throw or unexpected exceptions fail the test" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="CHECK_THROWS_AS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -4920,26 +4956,26 @@ C
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="FAIL aborts the test" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This is a failure
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="FAIL does not require an argument" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" />
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="FAIL_CHECK does not abort the test" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This is a failure
</Failure>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
This message appears in the output
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Factorials are computed" tags="[factorial]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -4982,7 +5018,18 @@ C
3628800 (0x<hex digits>) == 3628800 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Filter generator throws exception for empty generator" tags="[generators]" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
+ <Original>
+ filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
+ </Original>
+ <Expanded>
+ filter( []( int ) { return false; }, value( 3 ) ), Catch::GeneratorException
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Floating point matchers: double" tags="[floating-point][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Relative" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5027,9 +5074,9 @@ C
0.0 and 2.22507e-308 are within 2.22045e-12% of each other
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Margin" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5096,7 +5143,7 @@ C
-10.0 is within 0.5 of -9.6
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ULPs" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5155,7 +5202,7 @@ C
-0.0 is within 0 ULPs of 0.0000000000000000e+00 ([0.0000000000000000e+00, 0.0000000000000000e+00])
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Composed" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5182,7 +5229,7 @@ C
0.0001 ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Constructor validation" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5233,9 +5280,20 @@ C
WithinRel( 1., 1. ), std::domain_error
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="IsNaN" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ 1., !IsNaN()
+ </Original>
+ <Expanded>
+ 1.0 not is NaN
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Floating point matchers: float" tags="[floating-point][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Relative" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5280,9 +5338,9 @@ C
0.0f and 1.17549e-38 are within 0.00119209% of each other
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Margin" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5357,7 +5415,7 @@ C
-10.0f is within 0.5 of -9.6000003815
</Expanded>
</Expression>
- <OverallResults successes="9" failures="0" expectedFailures="0"/>
+ <OverallResults successes="9" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="ULPs" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5424,7 +5482,7 @@ C
-0.0f is within 0 ULPs of 0.00000000e+00f ([0.00000000e+00, 0.00000000e+00])
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Composed" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5451,7 +5509,7 @@ C
0.0001f ( is within 0.001 of 0.0 or and 0 are within 10% of each other )
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Constructor validation" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -5510,9 +5568,20 @@ C
WithinRel( 1.f, 1.f ), std::domain_error
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="IsNaN" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
+ <Original>
+ 1., !IsNaN()
+ </Original>
+ <Expanded>
+ 1.0 not is NaN
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Generators -- adapters" tags="[generators][generic]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5525,9 +5594,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5539,9 +5608,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5553,9 +5622,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filtering by predicate" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Throws if there are no matching values" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5567,9 +5636,9 @@ C
filter([] (int) {return false; }, value(1)), Catch::GeneratorException
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortening a range" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5580,7 +5649,7 @@ C
1 < 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortening a range" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5591,7 +5660,7 @@ C
2 < 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortening a range" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5602,7 +5671,7 @@ C
3 < 4
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Same type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5614,9 +5683,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Same type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5628,9 +5697,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Same type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5642,9 +5711,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5656,9 +5725,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5670,9 +5739,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5684,9 +5753,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different deduced type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5698,9 +5767,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different deduced type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5712,9 +5781,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Transforming elements" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Different deduced type" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5726,9 +5795,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5739,7 +5808,7 @@ C
1 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5750,7 +5819,7 @@ C
2 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5761,7 +5830,7 @@ C
3 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5772,7 +5841,7 @@ C
1 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5783,7 +5852,7 @@ C
2 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeating a generator" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5794,7 +5863,7 @@ C
3 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5814,9 +5883,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5836,9 +5905,9 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5858,9 +5927,9 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is not divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5888,9 +5957,9 @@ C
1 < 3
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Number of elements in source is not divisible by chunk size" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5918,9 +5987,9 @@ C
2 < 3
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Chunk size of zero" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5932,9 +6001,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Chunk size of zero" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5946,9 +6015,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Chunk size of zero" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5960,9 +6029,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Chunking a generator into sized pieces" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="Throws on too small generators" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5974,11 +6043,11 @@ C
chunk(2, value(1)), Catch::GeneratorException
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Generators -- simple" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -5990,7 +6059,7 @@ C
-3 < 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6001,7 +6070,7 @@ C
-2 < 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6012,7 +6081,7 @@ C
-1 < 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6023,7 +6092,7 @@ C
4 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6034,7 +6103,7 @@ C
4 > 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6045,7 +6114,7 @@ C
4 > 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6056,7 +6125,7 @@ C
-3 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6067,7 +6136,7 @@ C
-2 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6078,7 +6147,7 @@ C
-1 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6089,7 +6158,7 @@ C
8 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6100,7 +6169,7 @@ C
8 > 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6111,7 +6180,7 @@ C
8 > 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6122,7 +6191,7 @@ C
-3 < 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6133,7 +6202,7 @@ C
-2 < 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="one" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6144,7 +6213,7 @@ C
-1 < 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6155,7 +6224,7 @@ C
12 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6166,7 +6235,7 @@ C
12 > 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -6177,9 +6246,9 @@ C
12 > 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Generators internals" tags="[generators][internals]" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Single value" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6199,7 +6268,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Preset values" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6250,7 +6319,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Generator combinator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6333,7 +6402,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Explicitly typed generator sequence" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6392,7 +6461,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filter generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Simple filtering" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6428,9 +6497,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filter generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Filter out multiple elements at the start and end" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6466,9 +6535,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Filter generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Throws on construction if it can't get initial element" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6488,9 +6557,9 @@ C
filter([](int) { return false; }, values({ 1, 2, 3 })), Catch::GeneratorException
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Take less" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6526,9 +6595,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take generator" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Take more" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6548,9 +6617,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Map with explicit return type" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6601,7 +6670,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Map with deduced return type" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6652,7 +6721,7 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Singular repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6672,9 +6741,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Actual repeat" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6774,9 +6843,9 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive auto step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6845,11 +6914,11 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative auto step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6918,11 +6987,11 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -6992,13 +7061,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7068,13 +7137,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7160,19 +7229,19 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Floating Point" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Exact" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7183,7 +7252,7 @@ C
-1.0 == Approx( -1.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7194,7 +7263,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7205,7 +7274,7 @@ C
-0.9 == Approx( -0.9 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7216,7 +7285,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7227,7 +7296,7 @@ C
-0.8 == Approx( -0.8 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7238,7 +7307,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7249,7 +7318,7 @@ C
-0.7 == Approx( -0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7260,7 +7329,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7271,7 +7340,7 @@ C
-0.6 == Approx( -0.6 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7282,7 +7351,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7293,7 +7362,7 @@ C
-0.5 == Approx( -0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7304,7 +7373,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7315,7 +7384,7 @@ C
-0.4 == Approx( -0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7326,7 +7395,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7337,7 +7406,7 @@ C
-0.3 == Approx( -0.3 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7348,7 +7417,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7359,7 +7428,7 @@ C
-0.2 == Approx( -0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7370,7 +7439,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7381,7 +7450,7 @@ C
-0.1 == Approx( -0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7392,7 +7461,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1.38778e-16
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7403,7 +7472,7 @@ C
-0.0 == Approx( -0.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1.38778e-16
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7414,7 +7483,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7425,7 +7494,7 @@ C
0.1 == Approx( 0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7436,7 +7505,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7447,7 +7516,7 @@ C
0.2 == Approx( 0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7458,7 +7527,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7469,7 +7538,7 @@ C
0.3 == Approx( 0.3 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7480,7 +7549,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7491,7 +7560,7 @@ C
0.4 == Approx( 0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7502,7 +7571,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7513,7 +7582,7 @@ C
0.5 == Approx( 0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7524,7 +7593,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7535,7 +7604,7 @@ C
0.6 == Approx( 0.6 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7546,7 +7615,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7557,7 +7626,7 @@ C
0.7 == Approx( 0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7568,7 +7637,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7579,7 +7648,7 @@ C
0.8 == Approx( 0.8 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7590,7 +7659,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7601,7 +7670,7 @@ C
0.9 == Approx( 0.9 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7628,19 +7697,19 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="42" failures="0" expectedFailures="0"/>
+ <OverallResults successes="42" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Floating Point" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Slightly over end" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7651,7 +7720,7 @@ C
-1.0 == Approx( -1.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7662,7 +7731,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7673,7 +7742,7 @@ C
-0.7 == Approx( -0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7684,7 +7753,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7695,7 +7764,7 @@ C
-0.4 == Approx( -0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7706,7 +7775,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7717,7 +7786,7 @@ C
-0.1 == Approx( -0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7728,7 +7797,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7739,7 +7808,7 @@ C
0.2 == Approx( 0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7750,7 +7819,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7761,7 +7830,7 @@ C
0.5 == Approx( 0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7780,19 +7849,19 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Positive manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Floating Point" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Slightly under end" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7803,7 +7872,7 @@ C
-1.0 == Approx( -1.0 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7814,7 +7883,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7825,7 +7894,7 @@ C
-0.7 == Approx( -0.7 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7836,7 +7905,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7847,7 +7916,7 @@ C
-0.4 == Approx( -0.4 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7858,7 +7927,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7869,7 +7938,7 @@ C
-0.1 == Approx( -0.1 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is -0.1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7880,7 +7949,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7891,7 +7960,7 @@ C
0.2 == Approx( 0.2 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7902,7 +7971,7 @@ C
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7913,7 +7982,7 @@ C
0.5 == Approx( 0.5 )
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
Current expected value is 0.5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -7932,13 +8001,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="13" failures="0" expectedFailures="0"/>
+ <OverallResults successes="13" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -8008,13 +8077,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -8084,13 +8153,13 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Range" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
<Section name="Negative manual step" filename="tests/<exe-name>/IntrospectiveTests/GeneratorsImpl.tests.cpp" >
@@ -8176,15 +8245,15 @@ C
!false
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Greater-than inequalities with different epsilons" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -8219,7 +8288,7 @@ C
1.23 >= Approx( 1.24 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashers with different seed produce different hash with same test case" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8232,7 +8301,7 @@ C
130711275 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashers with same seed produce same hash" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8245,7 +8314,7 @@ C
3422778688 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashing different test cases produces different result" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Section name="Different test name" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8259,7 +8328,7 @@ C
2668622104 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different classname" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8272,7 +8341,7 @@ C
3916075712 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Different tags" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8285,9 +8354,9 @@ C
3429949824 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Hashing test case produces same hash across multiple calls" tags="[test-case-hash]" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestCaseInfoHasher.tests.cpp" >
@@ -8300,22 +8369,22 @@ C
3422778688 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="INFO and WARN do not abort tests" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this is a message
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this is a warning
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="INFO gets logged on failure" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
so should this
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8326,10 +8395,10 @@ C
2 == 1
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="INFO gets logged on failure, even if captured before successful assertions" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8340,10 +8409,10 @@ C
2 == 2
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8354,13 +8423,13 @@ C
2 == 1
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
and this, but later
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8371,16 +8440,16 @@ C
2 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message may be logged later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this message should be logged
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
and this, but later
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
but not this
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8391,13 +8460,13 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="INFO is reset for each loop" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 0
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 0
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8408,10 +8477,10 @@ C
0 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 1
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8422,10 +8491,10 @@ C
1 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 2
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8436,10 +8505,10 @@ C
2 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 3
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 3
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8450,10 +8519,10 @@ C
3 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 4
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8464,10 +8533,10 @@ C
4 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 5
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8478,10 +8547,10 @@ C
5 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 6
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 6
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8492,10 +8561,10 @@ C
6 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 7
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 7
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8506,10 +8575,10 @@ C
7 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 8
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 8
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8520,10 +8589,10 @@ C
8 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 9
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 9
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8534,10 +8603,10 @@ C
9 < 10
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
current counter 10
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 10
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -8548,7 +8617,7 @@ C
10 < 10
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Inequality checks that should fail" tags="[!shouldfail][.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -8591,7 +8660,7 @@ C
5 != 5
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Inequality checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -8682,7 +8751,7 @@ C
5 != 6
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Lambdas in assertions" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
@@ -8693,7 +8762,7 @@ C
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Less-than inequalities with different epsilons" tags="[Approx]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -8728,10 +8797,10 @@ C
1.23 <= Approx( 1.22 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="ManuallyRegistered" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be (AllOf) composed with the && operator" tags="[matchers][operator&&][operators]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8742,7 +8811,7 @@ C
"this string contains 'abc' as a substring" ( contains: "string" and contains: "abc" and contains: "substring" and contains: "contains" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be (AnyOf) composed with the || operator" tags="[matchers][operators][operator||]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8761,7 +8830,7 @@ C
"some completely different text that contains one common word" ( contains: "string" or contains: "different" or contains: "random" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be composed with both && and ||" tags="[matchers][operator&&][operators][operator||]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8772,7 +8841,7 @@ C
"this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "substring" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be composed with both && and || - failing" tags="[.][failing][matchers][operator&&][operators][operator||]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8783,7 +8852,7 @@ C
"this string contains 'abc' as a substring" ( ( contains: "string" or contains: "different" ) and contains: "random" )
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Matchers can be negated (Not) with the ! operator" tags="[matchers][not][operators]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8794,7 +8863,7 @@ C
"this string contains 'abc' as a substring" not contains: "different"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Matchers can be negated (Not) with the ! operator - failing" tags="[.][failing][matchers][not][operators]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -8805,44 +8874,44 @@ C
"this string contains 'abc' as a substring" not contains: "substring"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Mayfail test case with nested sections" tags="[!mayfail]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="A" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="1" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="A" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="2" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="A" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
- <OverallResults successes="0" failures="0" expectedFailures="0"/>
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="1" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Section name="2" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" />
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="0" expectedFailures="1"/>
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
<Section name="B" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
- <OverallResults successes="0" failures="0" expectedFailures="0"/>
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Mismatching exception messages failing the test" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -8861,7 +8930,7 @@ C
"expected exception" equals: "should fail"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Multireporter calls reporters and listeners in correct order" tags="[multi-reporter][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -8874,7 +8943,7 @@ C
{ "Hello", "world", "Goodbye", "world" }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Multireporter updates ReporterPreferences properly" tags="[multi-reporter][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -8942,7 +9011,7 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -9009,9 +9078,9 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Nested generators and captured variables" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -9142,19 +9211,19 @@ C
99 > -6
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Nice descriptive name" tags="[.][tag1][tag2][tag3]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
This one ran
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Non-std exceptions can be translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
custom exception
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Objects that evaluated in boolean contexts can be checked" tags="[SafeBool][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -9181,10 +9250,10 @@ C
!{?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Optionally static assertions" tags="[compilation]" filename="tests/<exe-name>/UsageTests/Compilation.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Ordering comparison checks that should fail" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -9339,7 +9408,7 @@ C
"hello" <= "a"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Ordering comparison checks that should succeed" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -9478,7 +9547,7 @@ C
"hello" > "a"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Our PCG implementation provides expected results for known seeds" tags="[rng]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Section name="Default seeded" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -9532,7 +9601,7 @@ C
1827115164 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Specific seed" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -9635,24 +9704,24 @@ C
4261393167 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Output from all sections is reported" tags="[.][failing][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Section name="one" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Message from section one
</Failure>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Message from section two
</Failure>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Overloaded comma or address-of operators are not used" tags="[matchers][templated]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -9687,1548 +9756,329 @@ C
( EvilMatcher() && EvilMatcher() ) || !EvilMatcher()
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="Parse test names and tags" tags="[command-line][test-spec]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="Empty test spec should have no filters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <TestCase name="Parse uints" tags="[parse-numbers]" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
+ <Section name="proper inputs" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == false
+ parseUInt( "0" ) == Optional<unsigned int>{ 0 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ parseUInt( "100" ) == Optional<unsigned int>{ 100 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ parseUInt( "4294967295" ) == Optional<unsigned int>{ 4294967295 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from empty string should have no filters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == false
+ parseUInt( "0x<hex digits>", 16 ) == Optional<unsigned int>{ 255 }
</Original>
<Expanded>
- false == false
+ {?} == {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Bad inputs" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(parseUInt( "" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ !(parseUInt( "!!KJHF*#" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from just a comma should have no filters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == false
+ !(parseUInt( "-1" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(parseUInt( "4294967296" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ !(parseUInt( "42949672964294967296429496729642949672964294967296" ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from name should have one filter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ !(parseUInt( "2 4" ))
</Original>
<Expanded>
- true == true
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Parse.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(parseUInt( "0x<hex digits>", 10 ))
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsed tags are matched case insensitive" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.hasFilters()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.getInvalidSpecs().empty()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.matches( testCase )
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsing sharding-related cli flags" tags="[sharding]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="shard-count" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == true
+ cli.parse({ "test", "--shard-count=8" })
</Original>
<Expanded>
- true == true
+ {?}
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Test spec from quoted name should have one filter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ config.shardCount == 8
</Original>
<Expanded>
- true == true
+ 8 == 8
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Negative shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ !(result)
</Original>
<Expanded>
- false == false
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == true
+ result.errorMessage(), ContainsSubstring( "Could not parse '-1' as shard count" )
</Original>
<Expanded>
- true == true
+ "Could not parse '-1' as shard count" contains: "Could not parse '-1' as shard count"
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Test spec from name should have one filter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="Zero shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ !(result)
</Original>
<Expanded>
- true == true
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ result.errorMessage(), ContainsSubstring( "Shard count must be positive" )
</Original>
<Expanded>
- false == false
+ "Shard count must be positive" contains: "Shard count must be positive"
</Expanded>
</Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="shard-index" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == true
+ cli.parse({ "test", "--shard-index=2" })
</Original>
<Expanded>
- true == true
+ {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcC ) == false
+ config.shardIndex == 2
</Original>
<Expanded>
- false == false
+ 2 == 2
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Wildcard at the start" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="Negative shard index reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.hasFilters() == true
+ !(result)
</Original>
<Expanded>
- true == true
+ !{?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcA ) == false
+ result.errorMessage(), ContainsSubstring( "Could not parse '-12' as shard index" )
</Original>
<Expanded>
- false == false
+ "Could not parse '-12' as shard index" contains: "Could not parse '-12' as shard index"
</Expanded>
</Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Shard index 0 is accepted" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcB ) == false
+ cli.parse({ "test", "--shard-index=0" })
</Original>
<Expanded>
- false == false
+ {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcC ) == true
+ config.shardIndex == 0
</Original>
<Expanded>
- true == true
+ 0 == 0
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsing tags with non-alphabetical characters is pass-through" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[tag with spaces]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.hasFilters()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[tag with spaces]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.getInvalidSpecs().empty()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[tag with spaces]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.matches( testCase )
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[I said "good day" sir!]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.hasFilters()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[I said "good day" sir!]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.getInvalidSpecs().empty()
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ tagString := "[I said "good day" sir!]"
+ </Info>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
+ <Original>
+ spec.matches( testCase )
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Parsing warnings" tags="[cli][warnings]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Section name="NoAssertions" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
- spec.matches( *tcD ) == false
+ cli.parse( { "test", "-w", "NoAssertions" } )
</Original>
<Expanded>
- false == false
+ {?}
</Expanded>
</Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- parseTestSpec( "*a" ).matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcard at the end" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- parseTestSpec( "a*" ).matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcard at both ends" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- parseTestSpec( "*a*" ).matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Redundant wildcard at the start" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Redundant wildcard at the end" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Redundant wildcard at both ends" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcard at both ends, redundant at start" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Just wildcard" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Single tag" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Single tag, two matches" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Two tags" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Two tags, spare separated" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Wildcarded name and tag" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Single tag exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="One tag exclusion and one tag inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="One tag exclusion and one wldcarded name inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="One tag exclusion, using exclude:, and one wldcarded name inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="name exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="wildcarded name exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="wildcarded name exclusion with tag inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="wildcarded name exclusion, using exclude:, with tag inclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="two wildcarded names" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="empty tag" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="empty quoted name" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="quoted string followed by tag exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.hasFilters() == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcA ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcB ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcC ) == false
- </Original>
- <Expanded>
- false == false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *tcD ) == true
- </Original>
- <Expanded>
- true == true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Leading and trailing spaces in test spec" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Leading and trailing spaces in test name" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( " aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark " ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches( *fakeTestCase( "aardvark" ) )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Shortened hide tags are split apart when parsing" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches(*fakeTestCase("hidden and foo", "[.][foo]"))
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("only foo", "[foo]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Shortened hide tags also properly handle exclusion" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("only foo", "[foo]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(spec.matches(*fakeTestCase("only hidden", "[.]")))
- </Original>
- <Expanded>
- !false
- </Expanded>
- </Expression>
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]"))
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
- </Section>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsed tags are matched case insensitive" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.hasFilters()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.getInvalidSpecs().empty()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.matches( testCase )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsing sharding-related cli flags" tags="[sharding]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="shard-count" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse({ "test", "--shard-count=8" })
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- config.shardCount == 8
- </Original>
- <Expanded>
- 8 == 8
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Negative shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(result)
- </Original>
- <Expanded>
- !{?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- result.errorMessage(), ContainsSubstring("Shard count must be a positive number")
- </Original>
- <Expanded>
- "Shard count must be a positive number" contains: "Shard count must be a positive number"
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Zero shard count reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(result)
- </Original>
- <Expanded>
- !{?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- result.errorMessage(), ContainsSubstring("Shard count must be a positive number")
- </Original>
- <Expanded>
- "Shard count must be a positive number" contains: "Shard count must be a positive number"
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="shard-index" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse({ "test", "--shard-index=2" })
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- config.shardIndex == 2
- </Original>
- <Expanded>
- 2 == 2
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Negative shard index reports error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- !(result)
- </Original>
- <Expanded>
- !{?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number")
- </Original>
- <Expanded>
- "Shard index must be a non-negative number" contains: "Shard index must be a non-negative number"
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Shard index 0 is accepted" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse({ "test", "--shard-index=0" })
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- config.shardIndex == 0
- </Original>
- <Expanded>
- 0 == 0
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsing tags with non-alphabetical characters is pass-through" tags="[test-spec][test-spec-parser]" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Info>
- tagString := "[tag with spaces]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.hasFilters()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[tag with spaces]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.getInvalidSpecs().empty()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[tag with spaces]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.matches( testCase )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[I said "good day" sir!]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.hasFilters()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[I said "good day" sir!]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.getInvalidSpecs().empty()
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <Info>
- tagString := "[I said "good day" sir!]"
- </Info>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/TestSpecParser.tests.cpp" >
- <Original>
- spec.matches( testCase )
- </Original>
- <Expanded>
- true
- </Expanded>
- </Expression>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Parsing warnings" tags="[cli][warnings]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Section name="NoAssertions" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Original>
- cli.parse( { "test", "-w", "NoAssertions" } )
- </Original>
- <Expanded>
- {?}
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Original>
config.warnings == WarnAbout::NoAssertions
</Original>
@@ -11236,7 +10086,7 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="NoTests is no longer supported" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11247,7 +10097,7 @@ C
!{?}
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Combining multiple warnings" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11266,9 +10116,9 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Pointers can be compared to null" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -11335,7 +10185,7 @@ C
0 != 0x<hex digits>
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Precision of floating point stringification can be set" tags="[floatingPoint][toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Floats" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -11355,7 +10205,7 @@ C
13 == 13
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Double" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -11374,9 +10224,9 @@ C
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Predicate matcher can accept const char*" tags="[compilation][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -11387,7 +10237,7 @@ C
"foo" matches undescribed predicate
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Process can be configured on command line" tags="[command-line][config]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="empty args don't cause a crash" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11407,7 +10257,7 @@ C
"" == ""
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="default - no arguments" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11498,7 +10348,7 @@ C
{?} == {?}
</Expanded>
</Expression>
- <OverallResults successes="11" failures="0" expectedFailures="0"/>
+ <OverallResults successes="11" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="test lists" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Specify one test case using" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11534,9 +10384,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="test lists" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Specify one test case exclusion using exclude:" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11572,9 +10422,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="test lists" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Specify one test case exclusion using ~" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11610,13 +10460,13 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-r/console" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11627,7 +10477,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11638,13 +10488,13 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-r/xml" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11655,7 +10505,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11666,13 +10516,13 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--reporter/junit" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11683,7 +10533,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11694,9 +10544,9 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="must match one of the available ones" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11716,13 +10566,13 @@ C
"Unrecognized reporter, 'unsupported'. Check available with --list-reporters" contains: "Unrecognized reporter"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="With output file" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11733,7 +10583,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11744,13 +10594,13 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="With Windows-like absolute path as output file" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11761,7 +10611,7 @@ C
{?}
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
result.errorMessage() := ""
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11772,9 +10622,9 @@ C
{ {?} } == { {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Multiple reporters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11795,11 +10645,11 @@ C
{ {?}, {?} } == { {?}, {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Multiple reporters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11820,11 +10670,11 @@ C
{ {?}, {?} } == { {?}, {?} }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="reporter" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Multiple reporters" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11845,11 +10695,11 @@ C
"Only one reporter may have unspecified output file." contains: "Only one reporter may have unspecified output file."
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="debugger" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-b" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11869,9 +10719,9 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="debugger" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--break" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11891,9 +10741,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-a aborts after first failure" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11913,9 +10763,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-x 2 aborts after two failures" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11935,9 +10785,9 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-x must be numeric" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11957,9 +10807,9 @@ C
"Unable to convert 'oops' to destination type" ( contains: "convert" and contains: "oops" )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -11980,11 +10830,11 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12005,11 +10855,11 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12030,11 +10880,11 @@ C
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12055,11 +10905,11 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="abort" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="wait-for-keypress" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12080,11 +10930,11 @@ C
"keypress argument must be one of: never, start, exit or both. 'sometimes' not recognised" ( contains: "never" and contains: "both" )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="nothrow" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-e" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12104,9 +10954,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="nothrow" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--nothrow" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12126,9 +10976,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="output filename" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="-o filename" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12148,9 +10998,9 @@ C
"filename.ext" == "filename.ext"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="output filename" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="--out" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12170,9 +11020,9 @@ C
"filename.ext" == "filename.ext"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="combinations" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="Single character flags can be combined" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12208,9 +11058,9 @@ C
true == true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="without option" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12230,9 +11080,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="auto" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12252,9 +11102,9 @@ C
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="yes" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12274,9 +11124,9 @@ C
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="no" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12296,9 +11146,9 @@ C
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="use-colour" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="error" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12318,9 +11168,9 @@ C
"colour mode must be one of: default, ansi, win32, or none. 'wrong' is not recognised" contains: "colour mode must be one of"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="samples" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12340,9 +11190,9 @@ C
200 == 200
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="resamples" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12362,9 +11212,9 @@ C
20000 (0x<hex digits>) == 20000 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="confidence-interval" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12384,9 +11234,9 @@ C
0.99 == Approx( 0.99 )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="no-analysis" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12406,9 +11256,9 @@ C
true
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Benchmark options" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
<Section name="warmup-time" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
@@ -12428,11 +11278,11 @@ C
10 == 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Product with differing arities - std::tuple<int, double, float>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -12443,7 +11293,7 @@ C
3 >= 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Product with differing arities - std::tuple<int, double>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -12454,7 +11304,7 @@ C
2 >= 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Product with differing arities - std::tuple<int>" tags="[product][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -12465,7 +11315,7 @@ C
1 >= 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Random seed generation accepts known methods" tags="[rng][seed]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -12492,7 +11342,7 @@ C
Catch::generateRandomSeed(method)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Random seed generation reports unknown methods" tags="[rng][seed]" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/RandomNumberGeneration.tests.cpp" >
@@ -12503,7 +11353,7 @@ C
Catch::generateRandomSeed(static_cast<Catch::GenerateFrom>(77))
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Range type with sentinel" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -12514,7 +11364,7 @@ C
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Reconstruction should be based on stringification: #914" tags="[.][Decomposition][failing]" filename="tests/<exe-name>/UsageTests/Decomposition.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Decomposition.tests.cpp" >
@@ -12525,7 +11375,7 @@ C
Hey, its truthy!
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Regex string matcher" tags="[.][failing][matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -12552,7 +11402,7 @@ C
"this string contains 'abc' as a substring" matches "this string contains 'abc' as a" case sensitively
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Registering reporter with '::' in name fails" tags="[registration][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_WITH" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12563,7 +11413,7 @@ C
"'::' is not allowed in reporter name: 'with::doublecolons'" equals: "'::' is not allowed in reporter name: 'with::doublecolons'"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Regression test #1" tags="[matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -12574,7 +11424,7 @@ C
{ 'a', 'b' } not UnorderedEquals: { 'c', 'b' }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Reporter's write listings to provided stream" tags="[reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12586,7 +11436,7 @@ C
</Expanded>
</Expression>
<Section name="Automake reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: Automake
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12601,7 +11451,7 @@ C
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12612,7 +11462,7 @@ C
</Expanded>
</Expression>
<Section name="Automake reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: Automake
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12626,7 +11476,7 @@ C
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12637,7 +11487,7 @@ C
</Expanded>
</Expression>
<Section name="Automake reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: Automake
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12653,7 +11503,7 @@ C
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12664,7 +11514,7 @@ C
</Expanded>
</Expression>
<Section name="compact reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: compact
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12679,7 +11529,7 @@ C
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12690,7 +11540,7 @@ C
</Expanded>
</Expression>
<Section name="compact reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: compact
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12704,7 +11554,7 @@ C
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12715,7 +11565,7 @@ C
</Expanded>
</Expression>
<Section name="compact reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: compact
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12731,7 +11581,7 @@ C
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12742,7 +11592,7 @@ C
</Expanded>
</Expression>
<Section name="console reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: console
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12757,7 +11607,7 @@ C
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12768,7 +11618,7 @@ C
</Expanded>
</Expression>
<Section name="console reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: console
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12782,7 +11632,7 @@ C
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12793,7 +11643,7 @@ C
</Expanded>
</Expression>
<Section name="console reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: console
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12809,7 +11659,7 @@ C
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12820,7 +11670,7 @@ C
</Expanded>
</Expression>
<Section name="JUnit reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: JUnit
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12836,7 +11686,7 @@ All available tags:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12847,7 +11697,7 @@ All available tags:
</Expanded>
</Expression>
<Section name="JUnit reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: JUnit
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12862,7 +11712,7 @@ Available reporters:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12873,7 +11723,7 @@ Available reporters:
</Expanded>
</Expression>
<Section name="JUnit reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: JUnit
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12890,7 +11740,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12901,7 +11751,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="SonarQube reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: SonarQube
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12917,7 +11767,7 @@ All available tags:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12928,7 +11778,7 @@ All available tags:
</Expanded>
</Expression>
<Section name="SonarQube reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: SonarQube
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12943,7 +11793,7 @@ Available reporters:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12954,7 +11804,7 @@ Available reporters:
</Expanded>
</Expression>
<Section name="SonarQube reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: SonarQube
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12971,7 +11821,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -12982,7 +11832,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TAP reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TAP
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -12997,7 +11847,7 @@ All available test cases:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13008,7 +11858,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TAP reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TAP
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13022,7 +11872,7 @@ All available test cases:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13033,7 +11883,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TAP reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TAP
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13049,7 +11899,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13060,7 +11910,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TeamCity reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TeamCity
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13075,7 +11925,7 @@ All available test cases:
" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13086,7 +11936,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TeamCity reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TeamCity
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13100,7 +11950,7 @@ All available test cases:
" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13111,7 +11961,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="TeamCity reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: TeamCity
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13127,7 +11977,7 @@ All available test cases:
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13138,7 +11988,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="XML reporter lists tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: XML
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13157,7 +12007,7 @@ All available test cases:
</TagsFromMatchingTests>" contains: "fakeTag"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13168,7 +12018,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="XML reporter lists reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: XML
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13185,7 +12035,7 @@ All available test cases:
</AvailableReporters>" contains: "fake reporter"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Original>
@@ -13196,7 +12046,7 @@ All available test cases:
</Expanded>
</Expression>
<Section name="XML reporter lists tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
Tested reporter: XML
</Info>
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -13218,18 +12068,18 @@ All available test cases:
</MatchingTests>" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Reproducer for #2309 - a very long description past 80 chars (default console width) with a late colon : blablabla" tags="[console-reporter]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="SUCCEED counts as a test pass" tags="[messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="SUCCEED does not require an argument" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: BDD tests requiring Fixtures to provide commonly-accessed data or methods" tags="[bdd][fixtures]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: No operations precede me" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13251,13 +12101,13 @@ All available test cases:
1 > 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: Do that thing with the thing" tags="[Tags]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: This stuff exists" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13281,29 +12131,29 @@ All available test cases:
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: This is a really long scenario name to see how the list command deals with wrapping" tags="[anotherReallyLongTagNameButThisOneHasNoObviousWrapPointsSoShouldSplitWithinAWordUsingADashCharacter][long][lots][one very long tag name that should cause line wrapping writing out using the list command][tags][verbose][very long tags]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: A section name that is so long that it cannot fit in a single console width" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="When: The test headers are printed as part of the normal running of the scenario" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Then: The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Scenario: Vector resizing affects size and capacity" tags="[bdd][capacity][size][vector]" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Section name="Given: an empty vector" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13351,15 +12201,15 @@ All available test cases:
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Given: an empty vector" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/BDD.tests.cpp" >
@@ -13388,16 +12238,16 @@ All available test cases:
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Sends stuff to stdout and stderr" tags="[.]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false">
+ <OverallResult success="false" skips="0">
<StdOut>
A string sent directly to stdout
</StdOut>
@@ -13472,16 +12322,16 @@ A string sent to stderr via clog
Approx( 1.23 ) != 1.24
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Standard output from all sections is reported" tags="[.][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Section name="one" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="two" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false">
+ <OverallResult success="false" skips="0">
<StdOut>
Message from section one
Message from section two
@@ -13505,7 +12355,7 @@ Message from section two
"this string contains 'abc' as a substring" starts with: "string" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Static arrays are convertible to string" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="Single item" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -13517,7 +12367,7 @@ Message from section two
"{ 1 }" == "{ 1 }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Multiple" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -13528,7 +12378,7 @@ Message from section two
"{ 3, 2, 1 }" == "{ 3, 2, 1 }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Non-trivial inner items" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -13541,9 +12391,9 @@ Message from section two
"{ { "1:1", "1:2", "1:3" }, { "2:1", "2:2" } }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="String matchers" tags="[matchers]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -13610,7 +12460,7 @@ Message from section two
"this string contains 'abc' as a substring" ends with: " substring" (case insensitive)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="StringRef" tags="[StringRef][Strings]" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Empty string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13638,7 +12488,7 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From string literal" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13673,7 +12523,7 @@ Message from section two
"hello" == "hello"
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From sub-string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13692,7 +12542,7 @@ Message from section two
original.data()
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Copy construction is shallow" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13703,7 +12553,7 @@ Message from section two
"original string" == "original string"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Copy assignment is shallow" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13714,7 +12564,7 @@ Message from section two
"original string" == "original string"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="zero-based substring" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13750,9 +12600,9 @@ Message from section two
hello == "hello"
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="non-zero-based substring" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13772,9 +12622,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Pointer values of full refs should match" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13786,9 +12636,9 @@ Message from section two
"hello world!" == "hello world!"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Pointer values of substring refs should also match" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13800,9 +12650,9 @@ Message from section two
"hello world!" == "hello world!"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Past the end substring" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13814,9 +12664,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Substring off the end are trimmed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13828,9 +12678,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Substrings" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="substring start after the end is empty" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13842,9 +12692,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Comparisons are deep" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13871,7 +12721,7 @@ Message from section two
Hello != Hel
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="implicitly constructed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13891,9 +12741,9 @@ Message from section two
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="explicitly constructed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13913,9 +12763,9 @@ Message from section two
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="from std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="assigned" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13935,9 +12785,9 @@ Message from section two
17 == 17
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="to std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="explicitly constructed" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13957,9 +12807,9 @@ Message from section two
11 == 11
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="to std::string" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="assigned" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13979,9 +12829,9 @@ Message from section two
11 == 11
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="std::string += StringRef" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -13994,7 +12844,7 @@ Message from section two
"some string += the stringref contents"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="StringRef + StringRef" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
@@ -14005,18 +12855,18 @@ Message from section two
"abrakadabra" == "abrakadabra"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="StringRef at compilation time" tags="[constexpr][StringRef][Strings]" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
<Section name="Simple constructors" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="UDL construction" filename="tests/<exe-name>/IntrospectiveTests/String.tests.cpp" >
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying char arrays with statically known sizes - char" tags="[toString]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -14035,7 +12885,7 @@ Message from section two
""abc"" == ""abc""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying char arrays with statically known sizes - signed char" tags="[toString]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -14054,7 +12904,7 @@ Message from section two
""abc"" == ""abc""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying char arrays with statically known sizes - unsigned char" tags="[toString]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -14073,7 +12923,7 @@ Message from section two
""abc"" == ""abc""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying std::chrono::duration helpers" tags="[chrono][toString]" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
@@ -14108,7 +12958,7 @@ Message from section two
1 ns != 1 us
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying std::chrono::duration with weird ratios" tags="[chrono][toString]" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
@@ -14127,7 +12977,7 @@ Message from section two
1 ps != 1 as
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Stringifying std::chrono::time_point<system_clock>" tags="[chrono][toString]" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringChrono.tests.cpp" >
@@ -14140,7 +12990,7 @@ Message from section two
{iso8601-timestamp}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Tabs and newlines show in output" tags="[.][failing][whitespace]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14158,7 +13008,7 @@ Message from section two
"
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Tag alias can be registered against tag patterns" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Section name="The same tag alias can only be registered once" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -14202,7 +13052,7 @@ Message from section two
Redefined at: file:10" contains: "10"
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Tag aliases must be of the form [@name]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="CHECK_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -14237,9 +13087,9 @@ Message from section two
registry.add( "[@no square bracket at end", "", Catch::SourceLineInfo( "file", 3 ) )
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Tags with spaces and non-alphanumerical characters are accepted" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -14258,7 +13108,7 @@ Message from section two
{ {?}, {?} } ( Contains: {?} and Contains: {?} )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case method with test types specified inside std::tuple - MyTypes - 0" tags="[class][list][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -14269,7 +13119,7 @@ Message from section two
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case method with test types specified inside std::tuple - MyTypes - 1" tags="[class][list][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -14280,7 +13130,7 @@ Message from section two
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case method with test types specified inside std::tuple - MyTypes - 2" tags="[class][list][template]" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Class.tests.cpp" >
@@ -14291,7 +13141,7 @@ Message from section two
1.0 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 0" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14302,7 +13152,7 @@ Message from section two
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-copyable and non-movable std::tuple - NonCopyableAndNonMovableTypes - 1" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14313,7 +13163,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 0" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14324,7 +13174,7 @@ Message from section two
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside non-default-constructible std::tuple - MyNonDefaultConstructibleTypes - 1" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14335,7 +13185,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside std::tuple - MyTypes - 0" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14346,7 +13196,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside std::tuple - MyTypes - 1" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14357,7 +13207,7 @@ Message from section two
1 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Template test case with test types specified inside std::tuple - MyTypes - 2" tags="[list][template]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14368,7 +13218,7 @@ Message from section two
4 > 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - float" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14404,7 +13254,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14448,9 +13298,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14485,7 +13335,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14520,9 +13370,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - int" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14558,7 +13408,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14602,9 +13452,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14639,7 +13489,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14674,9 +13524,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - std::string" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14712,7 +13562,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14756,9 +13606,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14793,7 +13643,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14828,9 +13678,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTest: vectors can be sized and resized - std::tuple<int,float>" tags="[template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -14866,7 +13716,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14910,9 +13760,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14947,7 +13797,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -14982,9 +13832,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - (std::tuple<int, float>), 6" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15020,7 +13870,7 @@ Message from section two
12 >= 12
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15064,9 +13914,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15101,7 +13951,7 @@ Message from section two
12 >= 12
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15136,9 +13986,9 @@ Message from section two
6 >= 6
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - float,4" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15174,7 +14024,7 @@ Message from section two
8 >= 8
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15218,9 +14068,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15255,7 +14105,7 @@ Message from section two
8 >= 8
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15290,9 +14140,9 @@ Message from section two
4 >= 4
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - int,5" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15328,7 +14178,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15372,9 +14222,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15409,7 +14259,7 @@ Message from section two
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15444,9 +14294,9 @@ Message from section two
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="TemplateTestSig: vectors can be sized and resized - std::string,15" tags="[nttp][template][vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15482,7 +14332,7 @@ Message from section two
30 >= 30
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15526,9 +14376,9 @@ Message from section two
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15563,7 +14413,7 @@ Message from section two
30 >= 30
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -15598,9 +14448,9 @@ Message from section two
15 >= 15
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test case with identical tags keeps just one" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -15619,10 +14469,10 @@ Message from section two
{?} == {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test case with one argument" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test enum bit values" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -15633,10 +14483,10 @@ Message from section two
3221225472 (0x<hex digits>) == 3221225472
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Test with special, characters "in name" tags="[cli][regression]" filename="tests/<exe-name>/IntrospectiveTests/CmdLine.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Testing checked-if" tags="[checked-if]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15671,7 +14521,7 @@ Message from section two
false
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Testing checked-if 2" tags="[!shouldfail][checked-if]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15683,7 +14533,7 @@ Message from section two
</Expanded>
</Expression>
<Failure filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" />
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Testing checked-if 3" tags="[!shouldfail][checked-if]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECKED_ELSE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -15695,7 +14545,7 @@ Message from section two
</Expanded>
</Expression>
<Failure filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" />
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="The NO_FAIL macro reports a failure but does not fail the test" tags="[messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Expression success="false" type="CHECK_NOFAIL" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -15706,7 +14556,7 @@ Message from section two
1 == 2
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="The default listing implementation write to provided stream" tags="[reporter-helpers][reporters]" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Section name="Listing tags" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15722,7 +14572,7 @@ Message from section two
" contains: "[fakeTag]"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Listing reporters" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15736,7 +14586,7 @@ Message from section two
" ( contains: "fake reporter" and contains: "fake description" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Listing tests" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15752,7 +14602,7 @@ Message from section two
" ( contains: "fake test name" and contains: "fakeTestTag" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Listing listeners" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Reporters.tests.cpp" >
@@ -15766,18 +14616,18 @@ Message from section two
" ( contains: "fakeListener" and contains: "fake description" )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="This test 'should' fail but doesn't" tags="[!shouldfail][.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Thrown string literals are translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
For some reason someone is throwing a string literal!
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Tracker" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
@@ -15829,7 +14679,7 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -15929,9 +14779,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16039,9 +14889,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="11" failures="0" expectedFailures="0"/>
+ <OverallResults successes="11" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16142,11 +14992,11 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="10" failures="0" expectedFailures="0"/>
+ <OverallResults successes="10" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16279,11 +15129,11 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="12" failures="0" expectedFailures="0"/>
+ <OverallResults successes="12" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="14" failures="0" expectedFailures="0"/>
+ <OverallResults successes="14" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/PartTracker.tests.cpp" >
<Original>
@@ -16350,9 +15200,9 @@ Message from section two
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Trim strings" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -16435,13 +15285,189 @@ There is no extra whitespace here
There is no extra whitespace here
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Type conversions of RangeEquals and similar" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different container types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, RangeEquals( c_array )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, UnorderedRangeEquals( c_array )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different container types (differ in array N)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_3, !RangeEquals( array_int_4 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_3, !UnorderedRangeEquals( array_int_4 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different container types and value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, RangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, UnorderedRangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Container conversions" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers, one random access, one not" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, RangeEquals( list_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_int_a, UnorderedRangeEquals( list_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, RangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, UnorderedRangeEquals( vector_char_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Value type" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal containers of different value types" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, !RangeEquals( vector_char_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_int_a, !UnorderedRangeEquals( vector_char_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 1, 2, 2 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Ranges with begin that needs ADL" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ a, !RangeEquals( b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 3, 2, 1 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ a, UnorderedRangeEquals( b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 3, 2, 1 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, RangeEquals( array_a_plus_1, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } elements are { 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, UnorderedRangeEquals( array_a_plus_1, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Unexpected exceptions can be translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
3.14
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Upcasting special member functions" tags="[internals][unique-ptr]" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Section name="Move constructor" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -16453,7 +15479,7 @@ There is no extra whitespace here
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="move assignment" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -16464,9 +15490,9 @@ There is no extra whitespace here
3 == 3
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AllMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16486,7 +15512,7 @@ There is no extra whitespace here
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not all match ( contains element 0 and contains element 1 )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16497,7 +15523,7 @@ There is no extra whitespace here
{ 1, 2, 3, 4, 5 } all match matches undescribed predicate
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16549,9 +15575,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16603,11 +15629,11 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AllTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16620,9 +15646,9 @@ There is no extra whitespace here
{ true, true, true, true, true } contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16634,12 +15660,12 @@ There is no extra whitespace here
{ } contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, !AllTrue()
@@ -16648,9 +15674,9 @@ There is no extra whitespace here
{ true, true, false, true, true } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16662,9 +15688,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16676,12 +15702,12 @@ There is no extra whitespace here
{ true, true, true, true, true } contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, !AllTrue()
@@ -16690,9 +15716,9 @@ There is no extra whitespace here
{ true, true, false, true, true } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16704,9 +15730,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains only true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16758,9 +15784,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16812,11 +15838,11 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AnyMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16836,7 +15862,7 @@ There is no extra whitespace here
{ { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not any match ( contains element 0 and contains element 10 )
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16847,7 +15873,7 @@ There is no extra whitespace here
{ 1, 2, 3, 4, 5 } any match matches undescribed predicate
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16899,9 +15925,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16953,11 +15979,11 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of AnyTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16970,9 +15996,9 @@ There is no extra whitespace here
{ true, true, true, true, true } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Empty evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16984,12 +16010,12 @@ There is no extra whitespace here
{ } not contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, AnyTrue()
@@ -16998,9 +16024,9 @@ There is no extra whitespace here
{ false, false, true, false, false } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17012,9 +16038,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17026,12 +16052,12 @@ There is no extra whitespace here
{ true, true, true, true, true } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
data, AnyTrue()
@@ -17040,9 +16066,9 @@ There is no extra whitespace here
{ false, false, true, false, false } contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17054,9 +16080,9 @@ There is no extra whitespace here
{ false, false, false, false, false } not contains at least one true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17108,9 +16134,9 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17146,67 +16172,276 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[3])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[4])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Usage of NoneMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, NoneMatch(SizeIs(6))
+ </Original>
+ <Expanded>
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } none match has size == 6
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneMatch(Contains(0) && Contains(1))
+ </Original>
+ <Expanded>
+ { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains element 1 )
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked, noneMatch
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[0]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[1]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[2]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[3]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[4]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked, !noneMatch
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ mocked.m_derefed[0]
+ </Original>
+ <Expanded>
+ true
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[1])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[2])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[3])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ !(mocked.m_derefed[4])
+ </Original>
+ <Expanded>
+ !false
+ </Expanded>
+ </Expression>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Usage of NoneTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneTrue()
+ </Original>
+ <Expanded>
+ { true, true, true, true, true } not contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, NoneTrue()
+ </Original>
+ <Expanded>
+ { } contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneTrue()
+ </Original>
+ <Expanded>
+ { false, false, true, false, false } not contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, NoneTrue()
+ </Original>
+ <Expanded>
+ { false, false, false, false, false } contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ data, !NoneTrue()
+ </Original>
+ <Expanded>
+ { true, true, true, true, true } not contains no true
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="One true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[3])
+ data, !NoneTrue()
</Original>
<Expanded>
- !false
+ { false, false, true, false, false } not contains no true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[4])
+ data, NoneTrue()
</Original>
<Expanded>
- !false
+ { false, false, false, false, false } contains no true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
- </Section>
- <OverallResult success="true"/>
- </TestCase>
- <TestCase name="Usage of NoneMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Original>
- data, NoneMatch(SizeIs(6))
- </Original>
- <Expanded>
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } none match has size == 6
- </Expanded>
- </Expression>
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Original>
- data, !NoneMatch(Contains(0) && Contains(1))
- </Original>
- <Expanded>
- { { 0, 1, 2, 3, 5 }, { 4, -3, -2, 5, 0 }, { 0, 0, 0, 5, 0 }, { 0, -5, 0, 5, 0 }, { 1, 0, 0, -1, 5 } } not none match ( contains element 0 and contains element 1 )
- </Expanded>
- </Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
- </Section>
- <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Original>
- needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) )
- </Original>
- <Expanded>
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
- </Expanded>
- </Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, noneMatch
+ mocked, NoneTrue()
</Original>
<Expanded>
- { 1, 2, 3, 4, 5 } none match matches undescribed predicate
+ { false, false, false, false, false } contains no true
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17249,18 +16484,18 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, !noneMatch
+ mocked, !NoneTrue()
</Original>
<Expanded>
- { 1, 2, 3, 4, 5 } not none match matches undescribed predicate
+ { false, false, true, true, true } not contains no true
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17271,20 +16506,20 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[1])
+ mocked.m_derefed[1]
</Original>
<Expanded>
- !false
+ true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[2])
+ mocked.m_derefed[2]
</Original>
<Expanded>
- !false
+ true
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17303,132 +16538,173 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <TestCase name="Usage of NoneTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <TestCase name="Usage of RangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ empty_vector, RangeEquals( empty_vector )
</Original>
<Expanded>
- { true, true, true, true, true } not contains no true
+ { } elements are { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, NoneTrue()
+ empty_vector, !RangeEquals( non_empty_vector )
</Original>
<Expanded>
- { } contains no true
+ { } not elements are { 1 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ non_empty_vector, !RangeEquals( empty_vector )
+ </Original>
+ <Expanded>
+ { 1 } not elements are { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ non_empty_array, RangeEquals( non_empty_array )
</Original>
<Expanded>
- { false, false, true, false, false } not contains no true
+ { 1 } elements are { 1 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, NoneTrue()
+ array_a, RangeEquals( array_a )
</Original>
<Expanded>
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } elements are { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ array_a, !RangeEquals( array_b )
</Original>
<Expanded>
- { true, true, true, true, true } not contains no true
+ { 1, 2, 3 } not elements are { 2, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_a, !RangeEquals( array_c )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not elements are { 1, 2, 2 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal-sized, non-empty containers (with same first elements)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, !NoneTrue()
+ vector_a, !RangeEquals( vector_b )
</Original>
<Expanded>
- { false, false, true, false, false } not contains no true
+ { 1, 2, 3 } not elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- data, NoneTrue()
+ vector_a, RangeEquals( vector_a_plus_1, close_enough )
</Original>
<Expanded>
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } elements are { 2, 3, 4 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, NoneTrue()
+ vector_a, !RangeEquals( vector_b, close_enough )
</Original>
<Expanded>
- { false, false, false, false, false } contains no true
+ { 1, 2, 3 } not elements are { 3, 3, 4 }
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Ranges that need ADL begin/end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl1, RangeEquals( needs_adl2 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } elements are { 1, 2, 3, 4, 5 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) { return l + 1 == r; } )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } elements are { 2, 3, 4, 5, 6 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Check short-circuiting behaviour" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Check short-circuits on failure" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[0]
+ mocked1, !RangeEquals( arr )
</Original>
<Expanded>
- true
+ { 1, 2, 3, 4 } not elements are { 1, 2, 4, 4 }
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[1]
+ mocked1.m_derefed[0]
</Original>
<Expanded>
true
@@ -17436,7 +16712,7 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[2]
+ mocked1.m_derefed[1]
</Original>
<Expanded>
true
@@ -17444,37 +16720,37 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[3]
+ mocked1.m_derefed[2]
</Original>
<Expanded>
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[4]
+ !(mocked1.m_derefed[3])
</Original>
<Expanded>
- true
+ !false
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
- <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Check short-circuiting behaviour" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="All elements are checked on success" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked, !NoneTrue()
+ mocked1, RangeEquals( arr )
</Original>
<Expanded>
- { false, false, true, true, true } not contains no true
+ { 1, 2, 3, 4 } elements are { 1, 2, 3, 4 }
</Expanded>
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[0]
+ mocked1.m_derefed[0]
</Original>
<Expanded>
true
@@ -17482,7 +16758,7 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[1]
+ mocked1.m_derefed[1]
</Original>
<Expanded>
true
@@ -17490,33 +16766,159 @@ There is no extra whitespace here
</Expression>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- mocked.m_derefed[2]
+ mocked1.m_derefed[2]
</Original>
<Expanded>
true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[3])
+ mocked1.m_derefed[3]
</Original>
<Expanded>
- !false
+ true
</Expanded>
</Expression>
- <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="Usage of UnorderedRangeEquals range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container matches empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Original>
- !(mocked.m_derefed[4])
+ empty_vector, UnorderedRangeEquals( empty_vector )
</Original>
<Expanded>
- !false
+ { } unordered elements are { }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Empty container does not match non-empty container" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ empty_vector, !UnorderedRangeEquals( non_empty_vector )
+ </Original>
+ <Expanded>
+ { } not unordered elements are { 1 }
+ </Expanded>
+ </Expression>
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ non_empty_vector, !UnorderedRangeEquals( empty_vector )
+ </Original>
+ <Expanded>
+ { 1 } not unordered elements are { }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal 1-length non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ non_empty_array, UnorderedRangeEquals( non_empty_array )
+ </Original>
+ <Expanded>
+ { 1 } unordered elements are { 1 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_a, UnorderedRangeEquals( array_a )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } unordered elements are { 1, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal-sized, non-equal, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ array_a, !UnorderedRangeEquals( array_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 2, 2, 3 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal-sized, non-empty containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, !UnorderedRangeEquals( vector_b )
+ </Original>
+ <Expanded>
+ { 1, 2, 3 } not unordered elements are { 1, 2, 3, 4 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, UnorderedRangeEquals( vector_a_plus_1, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 10, 20 } unordered elements are { 11, 21, 2 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Custom predicate" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Section name="Two non-equal non-empty containers (close enough)" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ vector_a, !UnorderedRangeEquals( vector_b, close_enough )
+ </Original>
+ <Expanded>
+ { 1, 10, 21 } not unordered elements are { 11, 21, 3 }
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="Ranges that need ADL begin/end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+ <Original>
+ needs_adl1, UnorderedRangeEquals( needs_adl2 )
+ </Original>
+ <Expanded>
+ { 1, 2, 3, 4, 5 } unordered elements are { 1, 2, 3, 4, 5 }
+ </Expanded>
+ </Expression>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Section name="Some with stdlib containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17576,7 +16978,7 @@ There is no extra whitespace here
{ {?}, {?}, {?} } has size == 3
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type requires ADL found size free function" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17587,7 +16989,7 @@ There is no extra whitespace here
{?} has size == 12
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Type has size member" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -17598,9 +17000,9 @@ There is no extra whitespace here
{?} has size == 13
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Use a custom approx" tags="[Approx][custom]" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Approx.tests.cpp" >
@@ -17667,13 +17069,13 @@ There is no extra whitespace here
Approx( 1.23 ) != 1.25
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Variadic macros" tags="[sections][variadic]" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
<Section name="Section with one argument" filename="tests/<exe-name>/UsageTests/VariadicMacros.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Vector Approx matcher" tags="[approx][matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Empty vector is roughly equal to an empty vector" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17685,7 +17087,7 @@ There is no extra whitespace here
{ } is approx: { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Vectors with elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="A vector is approx equal to itself" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17705,9 +17107,9 @@ There is no extra whitespace here
{ 1.0, 2.0, 3.0 } is approx: { 1.0, 2.0, 3.0 }
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Vectors with elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Different length" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17719,9 +17121,9 @@ There is no extra whitespace here
{ 1.0, 2.0, 3.0 } not is approx: { 1.0, 2.0, 3.0, 4.0 }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Vectors with elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Same length, different elements" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17757,11 +17159,11 @@ There is no extra whitespace here
{ 1.0, 2.0, 3.0 } is approx: { 1.5, 2.5, 3.5 }
</Expanded>
</Expression>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="4" failures="0" expectedFailures="0"/>
+ <OverallResults successes="4" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Vector Approx matcher -- failing" tags="[.][approx][failing][matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Empty and non empty vectors are not approx equal" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17773,7 +17175,7 @@ There is no extra whitespace here
{ } is approx: { 1.0, 2.0 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Just different vectors" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17784,9 +17186,9 @@ There is no extra whitespace here
{ 2.0, 4.0, 6.0 } is approx: { 1.0, 3.0, 5.0 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="Vector matchers" tags="[matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Contains (element)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17814,7 +17216,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Contains: 2
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contains (vector)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17881,7 +17283,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Contains: { 1, 2 }
</Expanded>
</Expression>
- <OverallResults successes="8" failures="0" expectedFailures="0"/>
+ <OverallResults successes="8" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contains (element), composed" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17892,7 +17294,7 @@ There is no extra whitespace here
{ 1, 2, 3 } ( Contains: 1 and Contains: 2 )
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Equals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -17943,7 +17345,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Equals: { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="UnorderedEquals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18002,9 +17404,9 @@ There is no extra whitespace here
{ 1, 3, 2 } UnorderedEquals: { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="7" failures="0" expectedFailures="0"/>
+ <OverallResults successes="7" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="Vector matchers that fail" tags="[.][failing][matchers][vector]" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Section name="Contains (element)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18024,7 +17426,7 @@ There is no extra whitespace here
{ } Contains: 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Contains (vector)" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18043,7 +17445,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Contains: { 1, 2, 4 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="2" expectedFailures="0"/>
+ <OverallResults successes="0" failures="2" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Equals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18078,7 +17480,7 @@ There is no extra whitespace here
{ 1, 2, 3 } Equals: { }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="4" expectedFailures="0"/>
+ <OverallResults successes="0" failures="4" expectedFailures="0" skipped="false"/>
</Section>
<Section name="UnorderedEquals" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
<Expression success="false" type="CHECK_THAT" filename="tests/<exe-name>/UsageTests/Matchers.tests.cpp" >
@@ -18113,9 +17515,9 @@ There is no extra whitespace here
{ 3, 1 } UnorderedEquals: { 1, 2, 3 }
</Expanded>
</Expression>
- <OverallResults successes="0" failures="4" expectedFailures="0"/>
+ <OverallResults successes="0" failures="4" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When checked exceptions are thrown they can be expected or unexpected" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS_AS" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18142,13 +17544,13 @@ There is no extra whitespace here
thisThrows()
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown directly they are always failures" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
unexpected exception
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown during a CHECK the test should continue" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18162,7 +17564,7 @@ There is no extra whitespace here
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown during a REQUIRE the test should abort fail" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18176,7 +17578,7 @@ There is no extra whitespace here
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown from functions they are always failures" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
@@ -18190,31 +17592,31 @@ There is no extra whitespace here
expected exception
</Exception>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown from sections they are always failures" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Section name="section name" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
unexpected exception
</Exception>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="When unchecked exceptions are thrown, but caught, they do not affect the test" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="X/level/0/a" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="X/level/0/b" tags="[fizz][Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="X/level/1/a" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="X/level/1/b" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="XmlEncode" tags="[XML]" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Section name="normal string" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18226,7 +17628,7 @@ There is no extra whitespace here
"normal string" == "normal string"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="empty string" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18237,7 +17639,7 @@ There is no extra whitespace here
"" == ""
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with ampersand" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18248,7 +17650,7 @@ There is no extra whitespace here
"smith &amp; jones" == "smith &amp; jones"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with less-than" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18259,7 +17661,7 @@ There is no extra whitespace here
"smith &lt; jones" == "smith &lt; jones"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with greater-than" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18280,7 +17682,7 @@ There is no extra whitespace here
"smith ]]&gt; jones"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with quotes" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18303,7 +17705,7 @@ There is no extra whitespace here
"don't &quot;quote&quot; me on that"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with control char (1)" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18314,7 +17716,7 @@ There is no extra whitespace here
"[\x01]" == "[\x01]"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="string with control char (x7F)" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18325,9 +17727,9 @@ There is no extra whitespace here
"[\x7F]" == "[\x7F]"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="XmlWriter writes boolean attributes as true/false" tags="[XML][XmlWriter]" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Xml.tests.cpp" >
@@ -18340,7 +17742,11 @@ There is no extra whitespace here
" ( contains: "attr1="true"" and contains: "attr2="false"" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="a succeeding test can still be skipped" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="analyse no analysis" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18447,7 +17853,7 @@ There is no extra whitespace here
0.0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="array<int, N> -> toString" tags="[array][containers][toString]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -18474,7 +17880,7 @@ There is no extra whitespace here
"{ 42, 250 }" == "{ 42, 250 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="benchmark function call" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Section name="without chronometer" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18518,7 +17924,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="with chronometer" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18561,9 +17967,9 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="boolean member" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -18574,7 +17980,7 @@ There is no extra whitespace here
0x<hex digits> != 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="checkedElse" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_ELSE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18593,7 +17999,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="checkedElse, failing" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECKED_ELSE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18612,7 +18018,7 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="checkedIf" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18631,7 +18037,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="checkedIf, failing" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECKED_IF" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -18650,7 +18056,7 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="classify_outliers" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Section name="none" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18702,7 +18108,7 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="low severe" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18753,7 +18159,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="low mild" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18804,7 +18210,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="high mild" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18855,7 +18261,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="high severe" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18906,7 +18312,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="mixed" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -18957,9 +18363,9 @@ There is no extra whitespace here
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="comparisons between const int variables" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -18994,7 +18400,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="comparisons between int variables" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Condition.tests.cpp" >
@@ -19029,7 +18435,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="convertToBits" tags="[conversion][floating-point]" filename="tests/<exe-name>/IntrospectiveTests/FloatingPoint.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/FloatingPoint.tests.cpp" >
@@ -19084,7 +18490,16 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="dynamic skipping works with generators" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ skipping because answer = 41
+ </Skip>
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ skipping because answer = 43
+ </Skip>
+ <OverallResult success="true" skips="2"/>
</TestCase>
<TestCase name="empty tags are not allowed" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -19095,7 +18510,7 @@ There is no extra whitespace here
Catch::TestCaseInfo("", { "test with an empty tag", "[]" }, dummySourceLineInfo)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="erfc_inv" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19122,7 +18537,7 @@ There is no extra whitespace here
1.3859038243 == Approx( 1.3859038243 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="estimate_clock_resolution" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19141,52 +18556,82 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="even more nested SECTION tests" tags="[sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="c" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="d (leaf)" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="c" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="e (leaf)" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="f (leaf)" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="failed assertions before SKIP cause test case to fail" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Original>
+ 3 == 4
+ </Original>
+ <Expanded>
+ 3 == 4
+ </Expanded>
+ </Expression>
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="1"/>
+ </TestCase>
+ <TestCase name="failing for some generator values causes entire test case to fail" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Failure filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <Failure filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="2"/>
+ </TestCase>
+ <TestCase name="failing in some unskipped sections causes entire test case to fail" tags="[!shouldfail][skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <Section name="not skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Failure filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="1" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="first tag" tags="[tag1]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="has printf" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="is_unary_function" tags="[clara][compilation]" filename="tests/<exe-name>/IntrospectiveTests/Clara.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="just failure" tags="[.][fail][isolated info][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Previous info should not be seen
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="just failure after unscoped info" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
<Failure filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
previous unscoped info SHOULD not be seen
</Failure>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="just info" tags="[info][isolated info][messages]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="just unscoped info" tags="[info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="long long" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19199,7 +18644,7 @@ There is no extra whitespace here
9223372036854775807 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="looped SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="b is currently: 0" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19211,7 +18656,7 @@ There is no extra whitespace here
0 > 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 1" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19222,7 +18667,7 @@ There is no extra whitespace here
1 > 1
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 2" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19233,7 +18678,7 @@ There is no extra whitespace here
2 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 3" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19244,7 +18689,7 @@ There is no extra whitespace here
3 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 4" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19255,7 +18700,7 @@ There is no extra whitespace here
4 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 5" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19266,7 +18711,7 @@ There is no extra whitespace here
5 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 6" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19277,7 +18722,7 @@ There is no extra whitespace here
6 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 7" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19288,7 +18733,7 @@ There is no extra whitespace here
7 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 8" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19299,7 +18744,7 @@ There is no extra whitespace here
8 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="b is currently: 9" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19310,12 +18755,12 @@ There is no extra whitespace here
9 > 1
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="looped tests" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[0] (1) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19326,7 +18771,7 @@ There is no extra whitespace here
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[1] (1) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19337,7 +18782,7 @@ There is no extra whitespace here
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[2] (2) is even
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19348,7 +18793,7 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[3] (3) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19359,7 +18804,7 @@ There is no extra whitespace here
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[4] (5) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19370,7 +18815,7 @@ There is no extra whitespace here
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[5] (8) is even
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19381,7 +18826,7 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[6] (13) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19392,7 +18837,7 @@ There is no extra whitespace here
1 == 0
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
Testing if fib[7] (21) is even
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19403,7 +18848,7 @@ There is no extra whitespace here
1 == 0
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="makeStream recognizes %debug stream name" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE_NOTHROW" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -19414,7 +18859,7 @@ There is no extra whitespace here
Catch::makeStream( "%debug" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="make_unique reimplementation" tags="[internals][unique-ptr]" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Section name="From lvalue copies" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -19426,7 +18871,7 @@ There is no extra whitespace here
!false
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="From rvalue moves" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -19437,7 +18882,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Variadic constructor" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -19448,9 +18893,9 @@ There is no extra whitespace here
{?} == {?}
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="mean" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19461,7 +18906,7 @@ There is no extra whitespace here
19.0 == 19.0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="measure" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19528,28 +18973,28 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="mix info, unscoped info and warning" tags="[info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
info
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
unscoped info
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
and warn may mix
</Warning>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
info
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
unscoped info
</Info>
- <Warning>
+ <Warning filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
they are not cleared after warnings
</Warning>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="more nested SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19562,9 +19007,9 @@ There is no extra whitespace here
1 == 2
</Expanded>
</Expression>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="0" failures="1" expectedFailures="0"/>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
</Section>
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="not equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19576,9 +19021,9 @@ There is no extra whitespace here
1 != 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="less than" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19590,11 +19035,11 @@ There is no extra whitespace here
1 < 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="nested SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19623,11 +19068,39 @@ There is no extra whitespace here
1 != 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="nested sections can be skipped dynamically at runtime" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="A" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="B" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="B1" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResults successes="0" failures="1" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="B" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="B2" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <Section name="B" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="false" skips="1">
+ <StdOut>
+a!
+b1!
+!
+ </StdOut>
+ </OverallResult>
</TestCase>
<TestCase name="non streamable - with conv. op" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19638,7 +19111,7 @@ There is no extra whitespace here
"7" == "7"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="non-copyable objects" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19649,7 +19122,7 @@ There is no extra whitespace here
{?} == {?}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="normal_cdf" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19692,7 +19165,7 @@ There is no extra whitespace here
0.088096521 == Approx( 0.088096521 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="normal_quantile" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -19719,13 +19192,13 @@ There is no extra whitespace here
-1.9599639845 == Approx( -1.9599639845 )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="not allowed" tags="[!throws]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="not prints unscoped info from previous failures" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY be seen only for the FIRST assertion IF info is printed for passing assertions
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19736,7 +19209,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY be seen only for the SECOND assertion IF info is printed for passing assertions
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19747,7 +19220,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD be seen
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19758,7 +19231,7 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="null strings" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19777,7 +19250,7 @@ There is no extra whitespace here
{null string} == {null string}
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="null_ptr" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19788,7 +19261,7 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="pair<pair<int,const char *,pair<std::string,int> > -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -19801,7 +19274,7 @@ There is no extra whitespace here
"{ { 42, "Arthur" }, { "Ford", 24 } }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="parseEnums" tags="[enums][Strings]" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Section name="No enums" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -19813,7 +19286,7 @@ There is no extra whitespace here
{ } Equals: { }
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="One enum value" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -19840,7 +19313,7 @@ There is no extra whitespace here
{ Value1 } Equals: { Value1 }
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Multiple enum values" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/IntrospectiveTests/ToString.tests.cpp" >
@@ -19867,9 +19340,9 @@ There is no extra whitespace here
{ Value1, Value2, Value3 } Equals: { Value1, Value2, Value3 }
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="pointer to class" tags="[Tricky]" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Tricky.tests.cpp" >
@@ -19880,10 +19353,10 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="print unscoped info if passing unscoped info is printed" tags="[info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY be seen IF info is printed for passing assertions
</Info>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19894,13 +19367,13 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="prints unscoped info on failure" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD be seen
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD also be seen
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19911,10 +19384,10 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="prints unscoped info only for the first assertion" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this SHOULD be seen only ONCE
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19933,7 +19406,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
this MAY also be seen only ONCE IF info is printed for passing assertions
</Info>
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -19952,7 +19425,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="random SECTION tests" tags="[.][failing][sections]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="doesn't equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19972,7 +19445,7 @@ There is no extra whitespace here
2 != 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="not equal" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -19983,9 +19456,9 @@ There is no extra whitespace here
1 != 2
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="replaceInPlace" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Section name="replace single char" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20005,7 +19478,7 @@ There is no extra whitespace here
"azcdefcg" == "azcdefcg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace two chars" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20024,7 +19497,7 @@ There is no extra whitespace here
"abzdefzg" == "abzdefzg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace first char" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20043,7 +19516,7 @@ There is no extra whitespace here
"zbcdefcg" == "zbcdefcg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace last char" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20062,7 +19535,7 @@ There is no extra whitespace here
"abcdefcz" == "abcdefcz"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace all chars" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20081,7 +19554,7 @@ There is no extra whitespace here
"replaced" == "replaced"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="replace no chars" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20100,7 +19573,7 @@ There is no extra whitespace here
"abcdefcg" == "abcdefcg"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="escape '" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20119,9 +19592,9 @@ There is no extra whitespace here
"didn|'t" == "didn|'t"
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="request an unknown %-starting stream fails" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE_THROWS" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -20132,7 +19605,7 @@ There is no extra whitespace here
Catch::makeStream( "%somestream" )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="resolution" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -20215,7 +19688,7 @@ There is no extra whitespace here
1000.0 == 1000 (0x<hex digits>)
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="run_for_at_least, chronometer" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -20306,7 +19779,7 @@ There is no extra whitespace here
128 >= 100
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="run_for_at_least, int" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -20397,13 +19870,26 @@ There is no extra whitespace here
128 >= 100
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="second tag" tags="[tag2]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
+ </TestCase>
+ <TestCase name="sections can be skipped dynamically at runtime" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Section name="not skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <Section name="skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResults successes="0" failures="0" expectedFailures="0" skipped="true"/>
+ </Section>
+ <Section name="also not skipped" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
+ </Section>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="send a single char to INFO" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
3
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20414,13 +19900,13 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="sends information to INFO" tags="[.][failing]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
hi
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
i := 7
</Info>
<Expression success="false" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -20431,7 +19917,7 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="shortened hide tags are split apart" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -20442,7 +19928,13 @@ There is no extra whitespace here
{ {?}, {?} } ( Contains: {?} and Contains: {?} )
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="skipped tests can optionally provide a reason" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ skipping because answer = 43
+ </Skip>
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="splitString" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK_THAT" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20469,19 +19961,19 @@ There is no extra whitespace here
{ abc, def } Equals: { abc, def }
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stacks unscoped info in loops" tags="[.][failing][info][unscoped]" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Count 1 to 3...
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
1
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
2
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
3
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -20492,16 +19984,16 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
Count 4 to 6...
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
4
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
5
</Info>
- <Info>
+ <Info filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
6
</Info>
<Expression success="false" type="CHECK" filename="tests/<exe-name>/UsageTests/Message.tests.cpp" >
@@ -20512,7 +20004,7 @@ There is no extra whitespace here
false
</Expanded>
</Expression>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="startsWith" tags="[string-manip]" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
<Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/StringManip.tests.cpp" >
@@ -20539,7 +20031,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::map is convertible string" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="empty" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20551,7 +20043,7 @@ There is no extra whitespace here
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="single item" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20562,7 +20054,7 @@ There is no extra whitespace here
"{ { "one", 1 } }" == "{ { "one", 1 } }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="several items" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20575,9 +20067,9 @@ There is no extra whitespace here
"{ { "abc", 1 }, { "def", 2 }, { "ghi", 3 } }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::pair<int,const std::string> -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -20588,7 +20080,7 @@ There is no extra whitespace here
"{ 34, "xyzzy" }" == "{ 34, "xyzzy" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::pair<int,std::string> -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -20599,7 +20091,7 @@ There is no extra whitespace here
"{ 34, "xyzzy" }" == "{ 34, "xyzzy" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::set is convertible string" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Section name="empty" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20611,7 +20103,7 @@ There is no extra whitespace here
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="single item" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20622,7 +20114,7 @@ There is no extra whitespace here
"{ "one" }" == "{ "one" }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="several items" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringGeneral.tests.cpp" >
@@ -20635,9 +20127,9 @@ There is no extra whitespace here
"{ "abc", "def", "ghi" }"
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="std::vector<std::pair<std::string,int> > -> toString" tags="[pair][toString]" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringPair.tests.cpp" >
@@ -20650,7 +20142,7 @@ There is no extra whitespace here
"{ { "green", 55 } }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stdout and stderr streams have %-starting name" tags="[streams]" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Stream.tests.cpp" >
@@ -20669,7 +20161,7 @@ There is no extra whitespace here
true
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify ranges" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20708,7 +20200,7 @@ There is no extra whitespace here
"{?}" == "{?}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_maker )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20721,7 +20213,7 @@ There is no extra whitespace here
"StringMaker<has_maker>"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_maker_and_operator )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20734,7 +20226,7 @@ There is no extra whitespace here
"StringMaker<has_maker_and_operator>"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_neither )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20745,7 +20237,7 @@ There is no extra whitespace here
"{?}" == "{?}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_operator )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20758,7 +20250,7 @@ There is no extra whitespace here
"operator<<( has_operator )"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( has_template_operator )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20771,7 +20263,7 @@ There is no extra whitespace here
"operator<<( has_template_operator )"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( vectors<has_maker> )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20784,7 +20276,7 @@ There is no extra whitespace here
"{ StringMaker<has_maker> }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( vectors<has_maker_and_operator> )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20797,7 +20289,7 @@ There is no extra whitespace here
"{ StringMaker<has_maker_and_operator> }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="stringify( vectors<has_operator> )" tags="[toString]" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringWhich.tests.cpp" >
@@ -20810,7 +20302,7 @@ There is no extra whitespace here
"{ operator<<( has_operator ) }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="strlen3" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -20845,7 +20337,7 @@ There is no extra whitespace here
4 == 4
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tables" tags="[generators]" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Generators.tests.cpp" >
@@ -20880,7 +20372,7 @@ There is no extra whitespace here
6 == 6
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tags with dots in later positions are not parsed as hidden" tags="[tags]" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/Tag.tests.cpp" >
@@ -20899,13 +20391,17 @@ There is no extra whitespace here
magic.tag == magic.tag
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
+ </TestCase>
+ <TestCase name="tests can be skipped dynamically at runtime" tags="[skipping]" filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" >
+ <Skip filename="tests/<exe-name>/UsageTests/Skip.tests.cpp" />
+ <OverallResult success="true" skips="1"/>
</TestCase>
<TestCase name="thrown std::strings are translated" tags="[!throws][.][failing]" filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
<Exception filename="tests/<exe-name>/UsageTests/Exception.tests.cpp" >
Why would you throw a std::string?
</Exception>
- <OverallResult success="false"/>
+ <OverallResult success="false" skips="0"/>
</TestCase>
<TestCase name="toString on const wchar_t const pointer returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20916,7 +20412,7 @@ There is no extra whitespace here
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString on const wchar_t pointer returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20927,7 +20423,7 @@ There is no extra whitespace here
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString on wchar_t const pointer returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20938,7 +20434,7 @@ There is no extra whitespace here
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString on wchar_t returns the string contents" tags="[toString]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -20949,7 +20445,7 @@ There is no extra whitespace here
""wide load"" == ""wide load""
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum class w/operator<<)" tags="[enum][enumClass][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -20978,7 +20474,7 @@ There is no extra whitespace here
"Unknown enum value 10"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum class)" tags="[enum][enumClass][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -20997,7 +20493,7 @@ There is no extra whitespace here
"1" == "1"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum w/operator<<)" tags="[enum][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -21016,7 +20512,7 @@ There is no extra whitespace here
"E2{1}" == "E2{1}"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="toString(enum)" tags="[enum][toString]" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/EnumToString.tests.cpp" >
@@ -21035,7 +20531,7 @@ There is no extra whitespace here
"1" == "1"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21054,7 +20550,7 @@ There is no extra whitespace here
"{ }" == "{ }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<float,int>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21073,7 +20569,7 @@ There is no extra whitespace here
"{ 1.2f, 0 }" == "{ 1.2f, 0 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<int>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21084,7 +20580,7 @@ There is no extra whitespace here
"{ 0 }" == "{ 0 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<string,string>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21097,7 +20593,7 @@ There is no extra whitespace here
"{ "hello", "world" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="tuple<tuple<int>,tuple<>,float>" tags="[toString][tuple]" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/UsageTests/ToStringTuple.tests.cpp" >
@@ -21110,7 +20606,7 @@ There is no extra whitespace here
"{ { 42 }, { }, 1.2f }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="uniform samples" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="CHECK" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -21145,7 +20641,7 @@ There is no extra whitespace here
0.95 == 0.95
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="unique_ptr reimplementation: basic functionality" tags="[internals][unique-ptr]" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Section name="Default constructed unique_ptr is empty" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21165,7 +20661,7 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take ownership of allocation" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21209,9 +20705,9 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="5" failures="0" expectedFailures="0"/>
+ <OverallResults successes="5" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Take ownership of allocation" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21263,9 +20759,9 @@ There is no extra whitespace here
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="6" failures="0" expectedFailures="0"/>
+ <OverallResults successes="6" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Release releases ownership" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="CHECK_FALSE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21284,7 +20780,7 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Move constructor" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21311,7 +20807,7 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="Move assignment" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21338,7 +20834,7 @@ There is no extra whitespace here
2 == 2
</Expanded>
</Expression>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="free swap" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/UniquePtr.tests.cpp" >
@@ -21357,9 +20853,9 @@ There is no extra whitespace here
1 == 1
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vec<vec<string,alloc>> -> toString" tags="[toString][vector,allocator]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21380,7 +20876,7 @@ There is no extra whitespace here
"{ { "hello" }, { "world" } }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<bool> -> toString" tags="[containers][toString][vector]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21407,7 +20903,7 @@ There is no extra whitespace here
"{ true, false }" == "{ true, false }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<int,allocator> -> toString" tags="[toString][vector,allocator]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21434,7 +20930,7 @@ There is no extra whitespace here
"{ 42, 250 }" == "{ 42, 250 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<int> -> toString" tags="[toString][vector]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21461,7 +20957,7 @@ There is no extra whitespace here
"{ 42, 250 }" == "{ 42, 250 }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vector<string> -> toString" tags="[toString][vector]" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/ToStringVector.tests.cpp" >
@@ -21490,7 +20986,7 @@ There is no extra whitespace here
"{ "hello", "world" }"
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="vectors can be sized and resized" tags="[vector]" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
@@ -21526,7 +21022,7 @@ There is no extra whitespace here
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -21570,9 +21066,9 @@ There is no extra whitespace here
0 == 0
</Expanded>
</Expression>
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResults successes="3" failures="0" expectedFailures="0"/>
+ <OverallResults successes="3" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -21607,7 +21103,7 @@ There is no extra whitespace here
10 >= 10
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Original>
@@ -21642,9 +21138,9 @@ There is no extra whitespace here
5 >= 5
</Expanded>
</Expression>
- <OverallResults successes="2" failures="0" expectedFailures="0"/>
+ <OverallResults successes="2" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="warmup" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -21663,7 +21159,7 @@ There is no extra whitespace here
310016000 ns > 100 ms
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="weighted_average_quantile" tags="[benchmark]" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
<Expression success="true" type="REQUIRE" filename="tests/<exe-name>/IntrospectiveTests/InternalBenchmark.tests.cpp" >
@@ -21690,17 +21186,17 @@ There is no extra whitespace here
23.0 == 23.0
</Expanded>
</Expression>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
<TestCase name="xmlentitycheck" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
<Section name="embedded xml: <test>it should be possible to embed xml characters, such as <, " or &, or even whole <xml>documents</xml> within an attribute</test>" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
<Section name="encoded chars: these should all be encoded: &&&"""<<<&"<<&"" filename="tests/<exe-name>/UsageTests/Misc.tests.cpp" >
- <OverallResults successes="1" failures="0" expectedFailures="0"/>
+ <OverallResults successes="1" failures="0" expectedFailures="0" skipped="false"/>
</Section>
- <OverallResult success="true"/>
+ <OverallResult success="true" skips="0"/>
</TestCase>
- <OverallResults successes="2129" failures="143" expectedFailures="27"/>
- <OverallResultsCases successes="304" failures="83" expectedFailures="7"/>
+ <OverallResults successes="2048" failures="145" expectedFailures="32" skips="12"/>
+ <OverallResultsCases successes="308" failures="84" expectedFailures="11" skips="6"/>
</Catch2TestRun>
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Algorithms.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Algorithms.tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa17cf82da5af402b6acabb137b2419dcc822085
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Algorithms.tests.cpp
@@ -0,0 +1,94 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/internal/catch_is_permutation.hpp>
+
+#include <helpers/range_test_helpers.hpp>
+
+#include <array>
+
+namespace {
+ template <typename Range1, typename Range2>
+ static bool is_permutation(Range1 const& r1, Range2 const& r2) {
+ using std::begin; using std::end;
+ return Catch::Detail::is_permutation(
+ begin( r1 ), end( r1 ), begin( r2 ), end( r2 ), std::equal_to<>{} );
+ }
+}
+
+TEST_CASE("is_permutation", "[algorithms][approvals]") {
+ SECTION( "Handle empty ranges" ) {
+ std::array<int, 0> empty;
+ std::array<int, 2> non_empty{ { 2, 3 } };
+ REQUIRE( is_permutation( empty, empty ) );
+ REQUIRE_FALSE( is_permutation( empty, non_empty ) );
+ REQUIRE_FALSE( is_permutation( non_empty, empty ) );
+ }
+ SECTION( "Different length ranges" ) {
+ std::array<int, 6> arr1{ { 1, 3, 5, 7, 8, 9 } };
+ // arr2 is prefix of arr1
+ std::array<int, 4> arr2{ { 1, 3, 5, 7 } };
+ // arr3 shares prefix with arr1 and arr2, but is not a permutation
+ std::array<int, 5> arr3{ { 1, 3, 5, 9, 8 } };
+ REQUIRE_FALSE( is_permutation( arr1, arr2 ) );
+ REQUIRE_FALSE( is_permutation( arr1, arr3 ) );
+ REQUIRE_FALSE( is_permutation( arr2, arr3 ) );
+ }
+ SECTION( "Same length ranges" ) {
+ SECTION( "Shared elements, but different counts" ) {
+ const std::array<int, 6>
+ arr1{ { 1, 1, 1, 1, 2, 2 } },
+ arr2{ { 1, 1, 2, 2, 2, 2 } };
+ REQUIRE_FALSE( is_permutation( arr1, arr2 ) );
+ }
+ SECTION( "Identical ranges" ) {
+ const std::array<int, 6>
+ arr1{ { 1, 1, 1, 1, 2, 2 } },
+ arr2{ { 1, 1, 2, 2, 2, 2 } };
+ REQUIRE( is_permutation( arr1, arr1 ) );
+ REQUIRE( is_permutation( arr2, arr2 ) );
+ }
+ SECTION( "Completely distinct elements" ) {
+ // Completely distinct elements
+ const std::array<int, 4>
+ arr1{ { 1, 2, 3, 4 } },
+ arr2{ { 10, 20, 30, 40 } };
+ REQUIRE_FALSE( is_permutation( arr1, arr2 ) );
+ }
+ SECTION( "Reverse ranges" ) {
+ const std::array<int, 5>
+ arr1{ { 1, 2, 3, 4, 5 } },
+ arr2{ { 5, 4, 3, 2, 1 } };
+ REQUIRE( is_permutation( arr1, arr2 ) );
+ }
+ SECTION( "Shared prefix & permuted elements" ) {
+ const std::array<int, 5>
+ arr1{ { 1, 1, 2, 3, 4 } },
+ arr2{ { 1, 1, 4, 2, 3 } };
+ REQUIRE( is_permutation( arr1, arr2 ) );
+ }
+ SECTION( "Permutations with element count > 1" ) {
+ const std::array<int, 7>
+ arr1{ { 2, 2, 3, 3, 3, 1, 1 } },
+ arr2{ { 3, 2, 1, 3, 2, 1, 3 } };
+ REQUIRE( is_permutation( arr1, arr2 ) );
+ }
+ }
+}
+
+TEST_CASE("is_permutation supports iterator + sentinel pairs",
+ "[algorithms][is-permutation][approvals]") {
+ const has_different_begin_end_types<int>
+ range_1{ 1, 2, 3, 4 },
+ range_2{ 4, 3, 2, 1 };
+ REQUIRE( is_permutation( range_1, range_2 ) );
+
+ const has_different_begin_end_types<int> range_3{ 3, 3, 2, 1 };
+ REQUIRE_FALSE( is_permutation( range_1, range_3 ) );
+}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Clara.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Clara.tests.cpp
index 2cbf05b8ea300c1d2e153286a04e45eac9b1bba9..14ba433dad17806bdc943aca60020d979a55d10b 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Clara.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Clara.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLine.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLine.tests.cpp
index e7b0c9c1634f94a2734882cac7f44ea8d5ae23d0..404bad278c5eba65f380e69cd5131a8bf517170b 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLine.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLine.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -22,311 +22,6 @@ namespace {
auto fakeTestCase(const char* name, const char* desc = "") { return Catch::makeTestCaseInfo("", { name, desc }, CATCH_INTERNAL_LINEINFO); }
}
-TEST_CASE( "Parse test names and tags", "[command-line][test-spec]" ) {
-
- using Catch::parseTestSpec;
- using Catch::TestSpec;
-
- auto tcA = fakeTestCase( "a" );
- auto tcB = fakeTestCase( "b", "[one][x]" );
- auto tcC = fakeTestCase( "longer name with spaces", "[two][three][.][x]" );
- auto tcD = fakeTestCase( "zlonger name with spacesz" );
-
- SECTION( "Empty test spec should have no filters" ) {
- TestSpec spec;
- CHECK( spec.hasFilters() == false );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- }
-
- SECTION( "Test spec from empty string should have no filters" ) {
- TestSpec spec = parseTestSpec( "" );
- CHECK( spec.hasFilters() == false );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- }
-
- SECTION( "Test spec from just a comma should have no filters" ) {
- TestSpec spec = parseTestSpec( "," );
- CHECK( spec.hasFilters() == false );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- }
-
- SECTION( "Test spec from name should have one filter" ) {
- TestSpec spec = parseTestSpec( "b" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == true );
- }
-
- SECTION( "Test spec from quoted name should have one filter" ) {
- TestSpec spec = parseTestSpec( "\"b\"" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == true );
- }
-
- SECTION( "Test spec from name should have one filter" ) {
- TestSpec spec = parseTestSpec( "b" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == false );
- }
-
- SECTION( "Wildcard at the start" ) {
- TestSpec spec = parseTestSpec( "*spaces" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == false );
- CHECK( parseTestSpec( "*a" ).matches( *tcA ) == true );
- }
- SECTION( "Wildcard at the end" ) {
- TestSpec spec = parseTestSpec( "long*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == false );
- CHECK( parseTestSpec( "a*" ).matches( *tcA ) == true );
- }
- SECTION( "Wildcard at both ends" ) {
- TestSpec spec = parseTestSpec( "*name*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == true );
- CHECK( parseTestSpec( "*a*" ).matches( *tcA ) == true );
- }
- SECTION( "Redundant wildcard at the start" ) {
- TestSpec spec = parseTestSpec( "*a" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == false );
- }
- SECTION( "Redundant wildcard at the end" ) {
- TestSpec spec = parseTestSpec( "a*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == false );
- }
- SECTION( "Redundant wildcard at both ends" ) {
- TestSpec spec = parseTestSpec( "*a*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == false );
- }
- SECTION( "Wildcard at both ends, redundant at start" ) {
- TestSpec spec = parseTestSpec( "*longer*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == true );
- }
- SECTION( "Just wildcard" ) {
- TestSpec spec = parseTestSpec( "*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == true );
- }
-
- SECTION( "Single tag" ) {
- TestSpec spec = parseTestSpec( "[one]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == false );
- }
- SECTION( "Single tag, two matches" ) {
- TestSpec spec = parseTestSpec( "[x]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == true );
- }
- SECTION( "Two tags" ) {
- TestSpec spec = parseTestSpec( "[two][x]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- }
- SECTION( "Two tags, spare separated" ) {
- TestSpec spec = parseTestSpec( "[two] [x]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- }
- SECTION( "Wildcarded name and tag" ) {
- TestSpec spec = parseTestSpec( "*name*[x]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == false );
- }
- SECTION( "Single tag exclusion" ) {
- TestSpec spec = parseTestSpec( "~[one]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == false );
- }
- SECTION( "One tag exclusion and one tag inclusion" ) {
- TestSpec spec = parseTestSpec( "~[two][x]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == false );
- }
- SECTION( "One tag exclusion and one wldcarded name inclusion" ) {
- TestSpec spec = parseTestSpec( "~[two]*name*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == false );
- CHECK( spec.matches( *tcD ) == true );
- }
- SECTION( "One tag exclusion, using exclude:, and one wldcarded name inclusion" ) {
- TestSpec spec = parseTestSpec( "exclude:[two]*name*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == false );
- CHECK( spec.matches( *tcD ) == true );
- }
- SECTION( "name exclusion" ) {
- TestSpec spec = parseTestSpec( "~b" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == false );
- CHECK( spec.matches( *tcD ) == true );
- }
- SECTION( "wildcarded name exclusion" ) {
- TestSpec spec = parseTestSpec( "~*name*" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == false );
- CHECK( spec.matches( *tcD ) == false );
- }
- SECTION( "wildcarded name exclusion with tag inclusion" ) {
- TestSpec spec = parseTestSpec( "~*name*,[three]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == false );
- }
- SECTION( "wildcarded name exclusion, using exclude:, with tag inclusion" ) {
- TestSpec spec = parseTestSpec( "exclude:*name*,[three]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == true );
- CHECK( spec.matches( *tcB ) == true );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == false );
- }
- SECTION( "two wildcarded names" ) {
- TestSpec spec = parseTestSpec( "\"longer*\"\"*spaces\"" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == true );
- CHECK( spec.matches( *tcD ) == false );
- }
- SECTION( "empty tag" ) {
- TestSpec spec = parseTestSpec( "[]" );
- CHECK( spec.hasFilters() == false );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == false );
- CHECK( spec.matches( *tcD ) == false );
- }
- SECTION( "empty quoted name" ) {
- TestSpec spec = parseTestSpec( "\"\"" );
- CHECK( spec.hasFilters() == false );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == false );
- CHECK( spec.matches( *tcD ) == false );
- }
- SECTION( "quoted string followed by tag exclusion" ) {
- TestSpec spec = parseTestSpec( "\"*name*\"~[.]" );
- CHECK( spec.hasFilters() == true );
- CHECK( spec.matches( *tcA ) == false );
- CHECK( spec.matches( *tcB ) == false );
- CHECK( spec.matches( *tcC ) == false );
- CHECK( spec.matches( *tcD ) == true );
- }
- SECTION( "Leading and trailing spaces in test spec" ) {
- TestSpec spec = parseTestSpec( "\" aardvark \"" );
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
- CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) );
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
- CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) );
- CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) );
-
- }
- SECTION( "Leading and trailing spaces in test name" ) {
- TestSpec spec = parseTestSpec( "aardvark" );
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
- CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) );
- CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
- CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) );
- CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) );
- }
- SECTION("Shortened hide tags are split apart when parsing") {
- TestSpec spec = parseTestSpec("[.foo]");
- CHECK(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")));
- CHECK_FALSE(spec.matches(*fakeTestCase("only foo", "[foo]")));
- }
- SECTION("Shortened hide tags also properly handle exclusion") {
- TestSpec spec = parseTestSpec("~[.foo]");
- CHECK_FALSE(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")));
- CHECK_FALSE(spec.matches(*fakeTestCase("only foo", "[foo]")));
- CHECK_FALSE(spec.matches(*fakeTestCase("only hidden", "[.]")));
- CHECK(spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")));
- }
-}
-
-TEST_CASE("#1905 -- test spec parser properly clears internal state between compound tests", "[command-line][test-spec]") {
- using Catch::parseTestSpec;
- using Catch::TestSpec;
- // We ask for one of 2 different tests and the latter one of them has a , in name that needs escaping
- TestSpec spec = parseTestSpec(R"("spec . char","spec \, char")");
-
- REQUIRE(spec.matches(*fakeTestCase("spec . char")));
- REQUIRE(spec.matches(*fakeTestCase("spec , char")));
- REQUIRE_FALSE(spec.matches(*fakeTestCase(R"(spec \, char)")));
-}
-
-TEST_CASE("#1912 -- test spec parser handles escaping", "[command-line][test-spec]") {
- using Catch::parseTestSpec;
- using Catch::TestSpec;
-
- SECTION("Various parentheses") {
- TestSpec spec = parseTestSpec(R"(spec {a} char,spec \[a] char)");
-
- REQUIRE(spec.matches(*fakeTestCase(R"(spec {a} char)")));
- REQUIRE(spec.matches(*fakeTestCase(R"(spec [a] char)")));
- REQUIRE_FALSE(spec.matches(*fakeTestCase("differs but has similar tag", "[a]")));
- }
- SECTION("backslash in test name") {
- TestSpec spec = parseTestSpec(R"(spec \\ char)");
-
- REQUIRE(spec.matches(*fakeTestCase(R"(spec \ char)")));
- }
-}
-
TEST_CASE( "Process can be configured on command line", "[config][command-line]" ) {
using namespace Catch::Matchers;
@@ -649,14 +344,18 @@ TEST_CASE("Parsing sharding-related cli flags", "[sharding]") {
auto result = cli.parse({ "test", "--shard-count=-1" });
CHECK_FALSE(result);
- REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Shard count must be a positive number"));
+ REQUIRE_THAT(
+ result.errorMessage(),
+ ContainsSubstring( "Could not parse '-1' as shard count" ) );
}
SECTION("Zero shard count reports error") {
auto result = cli.parse({ "test", "--shard-count=0" });
CHECK_FALSE(result);
- REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Shard count must be a positive number"));
+ REQUIRE_THAT(
+ result.errorMessage(),
+ ContainsSubstring( "Shard count must be positive" ) );
}
SECTION("shard-index") {
@@ -669,7 +368,9 @@ TEST_CASE("Parsing sharding-related cli flags", "[sharding]") {
auto result = cli.parse({ "test", "--shard-index=-12" });
CHECK_FALSE(result);
- REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number"));
+ REQUIRE_THAT(
+ result.errorMessage(),
+ ContainsSubstring( "Could not parse '-12' as shard index" ) );
}
SECTION("Shard index 0 is accepted") {
@@ -677,7 +378,6 @@ TEST_CASE("Parsing sharding-related cli flags", "[sharding]") {
REQUIRE(config.shardIndex == 0);
}
-
}
TEST_CASE( "Parsing warnings", "[cli][warnings]" ) {
@@ -737,3 +437,31 @@ TEST_CASE("Win32 colour implementation is compile-time optional",
REQUIRE_FALSE( result );
#endif
}
+
+TEST_CASE( "Parse rng seed in different formats", "[approvals][cli][rng-seed]" ) {
+ Catch::ConfigData config;
+ auto cli = Catch::makeCommandLineParser( config );
+
+ SECTION("well formed cases") {
+ char const* seed_string;
+ uint32_t seed_value;
+ // GCC-5 workaround
+ using gen_type = std::tuple<char const*, uint32_t>;
+ std::tie( seed_string, seed_value ) = GENERATE( table<char const*, uint32_t>({
+ gen_type{ "0xBEEF", 0xBEEF },
+ gen_type{ "12345678", 12345678 }
+ } ) );
+ CAPTURE( seed_string );
+
+ auto result = cli.parse( { "tests", "--rng-seed", seed_string } );
+
+ REQUIRE( result );
+ REQUIRE( config.rngSeed == seed_value );
+ }
+ SECTION( "Error cases" ) {
+ auto seed_string =
+ GENERATE( "0xSEED", "999999999999", "08888", "BEEF", "123 456" );
+ CAPTURE( seed_string );
+ REQUIRE_FALSE( cli.parse( { "tests", "--rng-seed", seed_string } ) );
+ }
+}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp
index b8a543903748b580796c59222855fc1f96f6c0ec..4df8ecf9e8d76e248ba832974cf575a4554bfcae 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/ColourImpl.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/ColourImpl.tests.cpp
index 83501cae51f155a0a5e7630ee84ebe1395eefdc4..615fda1d910f44d37968614bbe6759d33ca77861 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/ColourImpl.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/ColourImpl.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Details.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Details.tests.cpp
index 987910a948abe74947e07279b4b4bdf940988c11..d7175756b5c6b212ebdacf43afbdc19ed137f8ea 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Details.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Details.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -11,6 +11,8 @@
#include <catch2/internal/catch_case_insensitive_comparisons.hpp>
#include <catch2/internal/catch_optional.hpp>
+#include <helpers/type_with_lit_0_comparisons.hpp>
+
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4702) // unreachable code in the macro expansions
@@ -86,3 +88,85 @@ TEST_CASE("Optional comparison ops", "[optional][approvals]") {
REQUIRE_FALSE( a != b );
}
}
+
+namespace {
+ struct MoveChecker {
+ bool has_moved = false;
+ MoveChecker() = default;
+ MoveChecker( MoveChecker const& rhs ) = default;
+ MoveChecker& operator=( MoveChecker const& rhs ) = default;
+ MoveChecker( MoveChecker&& rhs ) noexcept { rhs.has_moved = true; }
+ MoveChecker& operator=( MoveChecker&& rhs ) noexcept {
+ rhs.has_moved = true;
+ return *this;
+ }
+ };
+}
+
+TEST_CASE( "Optional supports move ops", "[optional][approvals]" ) {
+ using Catch::Optional;
+ MoveChecker a;
+ Optional<MoveChecker> opt_A( a );
+ REQUIRE_FALSE( a.has_moved );
+ REQUIRE_FALSE( opt_A->has_moved );
+
+ SECTION( "Move construction from element" ) {
+ Optional<MoveChecker> opt_B( CATCH_MOVE( a ) );
+ REQUIRE( a.has_moved );
+ }
+ SECTION( "Move assignment from element" ) {
+ opt_A = CATCH_MOVE( a );
+ REQUIRE( a.has_moved );
+ }
+ SECTION( "Move construction from optional" ) {
+ Optional<MoveChecker> opt_B( CATCH_MOVE( opt_A ) );
+ REQUIRE( opt_A->has_moved );
+ }
+ SECTION( "Move assignment from optional" ) {
+ Optional<MoveChecker> opt_B( opt_A );
+ REQUIRE_FALSE( opt_A->has_moved );
+ opt_B = CATCH_MOVE( opt_A );
+ REQUIRE( opt_A->has_moved );
+ }
+}
+
+TEST_CASE( "Decomposer checks that the argument is 0 when handling "
+ "only-0-comparable types",
+ "[decomposition][approvals]" ) {
+ TypeWithLit0Comparisons t{};
+
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+ CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+
+ REQUIRE_THROWS( Catch::Decomposer{} <= t == 42 );
+ REQUIRE_THROWS( Catch::Decomposer{} <= 42 == t );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= t == 0 );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 == t );
+
+ REQUIRE_THROWS( Catch::Decomposer{} <= t != 42 );
+ REQUIRE_THROWS( Catch::Decomposer{} <= 42 != t );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= t != 0 );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 != t );
+
+ REQUIRE_THROWS( Catch::Decomposer{} <= t < 42 );
+ REQUIRE_THROWS( Catch::Decomposer{} <= 42 < t );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= t < 0 );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 < t );
+
+ REQUIRE_THROWS( Catch::Decomposer{} <= t <= 42 );
+ REQUIRE_THROWS( Catch::Decomposer{} <= 42 <= t );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= t <= 0 );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 <= t );
+
+ REQUIRE_THROWS( Catch::Decomposer{} <= t > 42 );
+ REQUIRE_THROWS( Catch::Decomposer{} <= 42 > t );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= t > 0 );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 > t );
+
+ REQUIRE_THROWS( Catch::Decomposer{} <= t >= 42 );
+ REQUIRE_THROWS( Catch::Decomposer{} <= 42 >= t );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= t >= 0 );
+ REQUIRE_NOTHROW( Catch::Decomposer{} <= 0 >= t );
+
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp
index 242a89670d2126d82fcead01c05f006212e3c51a..08a579c9dc5c0aa2dcfbbb602bc56c34dfab164d 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp
index 3ad20453c59ca1b15f4a6d0fd80732dfb430b656..f7b7c57cc354f5bd10ba48c8e08c3bf94cdaf6b7 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -16,6 +16,7 @@
#include <catch2/generators/catch_generators_adapters.hpp>
#include <catch2/generators/catch_generators_random.hpp>
#include <catch2/generators/catch_generators_range.hpp>
+#include <catch2/generators/catch_generator_exception.hpp>
// Tests of generator implementation details
TEST_CASE("Generators internals", "[generators][internals]") {
@@ -411,6 +412,7 @@ TEST_CASE("GENERATE handles function (pointers)", "[generators][compilation][app
TEST_CASE("GENERATE decays arrays", "[generators][compilation][approvals]") {
auto str = GENERATE("abc", "def", "gh");
+ (void)str;
STATIC_REQUIRE(std::is_same<decltype(str), const char*>::value);
}
@@ -534,3 +536,12 @@ TEST_CASE( "Random generators can be seeded", "[generators][approvals]" ) {
}
}
}
+
+TEST_CASE("Filter generator throws exception for empty generator",
+ "[generators]") {
+ using namespace Catch::Generators;
+
+ REQUIRE_THROWS_AS(
+ filter( []( int ) { return false; }, value( 3 ) ),
+ Catch::GeneratorException );
+}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp
index f51f7bd9d4dd5d4d24747ba6b9443a6faeb45f82..24bfe68cd6dea8eb2bbdfe18fa677335c98d613e 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -22,6 +22,8 @@
#include <catch2/benchmark/detail/catch_benchmark_function.hpp>
#include <catch2/benchmark/detail/catch_estimate_clock.hpp>
+#include <numeric>
+
namespace {
struct manual_clock {
public:
@@ -442,6 +444,6 @@ TEST_CASE("Failing benchmarks", "[!benchmark][.approvals]") {
}
TEST_CASE( "Failing benchmark respects should-fail",
- "[!shouldfail][!benchmark][.approvals]" ) {
+ "[!shouldfail][!benchmark][approvals]" ) {
BENCHMARK( "Asserting benchmark" ) { REQUIRE( 1 == 2 ); };
}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Parse.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Parse.tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7791355f58b34ece7a697153dc8be23aace0d186
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Parse.tests.cpp
@@ -0,0 +1,38 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <catch2/internal/catch_parse_numbers.hpp>
+
+TEST_CASE("Parse uints", "[parse-numbers]") {
+ using Catch::parseUInt;
+ using Catch::Optional;
+
+ SECTION("proper inputs") {
+ REQUIRE( parseUInt( "0" ) == Optional<unsigned int>{ 0 } );
+ REQUIRE( parseUInt( "100" ) == Optional<unsigned int>{ 100 } );
+ REQUIRE( parseUInt( "4294967295" ) ==
+ Optional<unsigned int>{ 4294967295 } );
+ REQUIRE( parseUInt( "0xFF", 16 ) == Optional<unsigned int>{ 255 } );
+ }
+ SECTION( "Bad inputs" ) {
+ // empty
+ REQUIRE_FALSE( parseUInt( "" ) );
+ // random noise
+ REQUIRE_FALSE( parseUInt( "!!KJHF*#" ) );
+ // negative
+ REQUIRE_FALSE( parseUInt( "-1" ) );
+ // too large
+ REQUIRE_FALSE( parseUInt( "4294967296" ) );
+ REQUIRE_FALSE( parseUInt( "42949672964294967296429496729642949672964294967296" ) );
+ REQUIRE_FALSE( parseUInt( "2 4" ) );
+ // hex with base 10
+ REQUIRE_FALSE( parseUInt( "0xFF", 10 ) );
+ }
+}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/PartTracker.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/PartTracker.tests.cpp
index 025a286043a5b98e04d2c169bfd81b5205ac87f5..c13ec573e63561aad106e7ba5ff247fdf85bfb5d 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/PartTracker.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/PartTracker.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -14,8 +14,8 @@
using namespace Catch;
namespace {
-Catch::TestCaseTracking::NameAndLocation makeNAL( std::string const& name ) {
- return Catch::TestCaseTracking::NameAndLocation( name, Catch::SourceLineInfo("",0) );
+Catch::TestCaseTracking::NameAndLocationRef makeNAL( StringRef name ) {
+ return Catch::TestCaseTracking::NameAndLocationRef( name, Catch::SourceLineInfo("",0) );
}
}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp
index b79b372e977150cb266df29e462f2293c558a337..8018b7eb0d8660cf517ffb82f2dc81c3ae7ea275 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Reporters.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Reporters.tests.cpp
index 97d1ad25307f6762eb0326cd39939f4fed82345d..1568c951692fba61bf3f00171ab689418ed5b547 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Reporters.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Reporters.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -12,7 +12,6 @@
#include <catch2/catch_config.hpp>
#include <catch2/interfaces/catch_interfaces_reporter.hpp>
#include <catch2/interfaces/catch_interfaces_reporter_factory.hpp>
-#include <catch2/interfaces/catch_interfaces_reporter_registry.hpp>
#include <catch2/internal/catch_console_colour.hpp>
#include <catch2/internal/catch_enforce.hpp>
#include <catch2/internal/catch_list.hpp>
@@ -164,7 +163,7 @@ namespace {
std::vector<std::string>& recorder,
Catch::IConfig const* config ):
EventListenerBase( config ),
- m_witness( witness ),
+ m_witness( CATCH_MOVE(witness) ),
m_recorder( recorder )
{}
@@ -182,7 +181,7 @@ namespace {
std::vector<std::string>& recorder,
Catch::ReporterConfig&& config ):
StreamingReporterBase( CATCH_MOVE(config) ),
- m_witness( witness ),
+ m_witness( CATCH_MOVE(witness) ),
m_recorder( recorder )
{}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Sharding.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Sharding.tests.cpp
index 78e4858a0297b8609c7667bc9ecfb94f742c970b..8e6009dd581864c6d8801674a872b737e69d5b20 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Sharding.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Sharding.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Stream.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Stream.tests.cpp
index 6b1d377c854776c6b314610b650d8f6342686e48..738cb529c9b954b79961cfd35c5c3b489b678a3b 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Stream.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Stream.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/String.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/String.tests.cpp
index 08f7dc2c6ace98eb78edf56b270bf0cbeda30a9e..7a0b3b4ab445ec3b9fd96cc47652e671a5ed3f4e 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/String.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/String.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/StringManip.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/StringManip.tests.cpp
index 8cd995cce9c80391f1b3598ea3c653f945079289..36554ddc3b422ee9ae169cd8928d0e905b4c9aab 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/StringManip.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/StringManip.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Tag.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Tag.tests.cpp
index d87f966bde4960354b04bdf703543a6d3b4ce99b..43723758d0ea11f21c5a01a4f4ec6eb1c986137a 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Tag.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Tag.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -98,7 +98,20 @@ TEST_CASE( "Test case with identical tags keeps just one", "[tags]" ) {
REQUIRE( testCase.tags[0] == Tag( "tag1" ) );
}
-TEST_CASE( "Empty tag is not allowed" ) {
- REQUIRE_THROWS( Catch::TestCaseInfo(
- "", { "fake test name", "[]" }, dummySourceLineInfo ) );
+TEST_CASE("Mismatched square brackets in tags are caught and reported",
+ "[tags][approvals]") {
+ using Catch::TestCaseInfo;
+ using Catch::Matchers::ContainsSubstring;
+ REQUIRE_THROWS_WITH( TestCaseInfo( "",
+ { "test with unclosed tag", "[abc" },
+ dummySourceLineInfo ),
+ ContainsSubstring("registering test case 'test with unclosed tag'") );
+ REQUIRE_THROWS_WITH( TestCaseInfo( "",
+ { "test with nested tags", "[abc[def]]" },
+ dummySourceLineInfo ),
+ ContainsSubstring("registering test case 'test with nested tags'") );
+ REQUIRE_THROWS_WITH( TestCaseInfo( "",
+ { "test with superfluous close tags", "[abc][def]]" },
+ dummySourceLineInfo ),
+ ContainsSubstring("registering test case 'test with superfluous close tags'") );
}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
index 93cb70b14a51f065e0731c90c92475769b1bfe43..03cb3f0e2aeea3bc92d646ca7ea1e74a2a42a1ee 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestSpec.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestSpec.tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9c4eb03b1a7b82f4208d8278c4d48296e543a77a
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestSpec.tests.cpp
@@ -0,0 +1,365 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_config.hpp>
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_string.hpp>
+#include <catch2/internal/catch_test_spec_parser.hpp>
+#include <catch2/catch_user_config.hpp>
+#include <catch2/catch_test_case_info.hpp>
+#include <catch2/internal/catch_commandline.hpp>
+#include <catch2/generators/catch_generators.hpp>
+#include <catch2/internal/catch_compiler_capabilities.hpp>
+
+#include <helpers/parse_test_spec.hpp>
+
+namespace {
+ auto fakeTestCase(const char* name, const char* desc = "") { return Catch::makeTestCaseInfo("", { name, desc }, CATCH_INTERNAL_LINEINFO); }
+}
+
+TEST_CASE( "Parse test names and tags", "[command-line][test-spec][approvals]" ) {
+ using Catch::parseTestSpec;
+ using Catch::TestSpec;
+
+ auto tcA = fakeTestCase( "a" );
+ auto tcB = fakeTestCase( "b", "[one][x]" );
+ auto tcC = fakeTestCase( "longer name with spaces", "[two][three][.][x]" );
+ auto tcD = fakeTestCase( "zlonger name with spacesz" );
+
+ SECTION( "Empty test spec should have no filters" ) {
+ TestSpec spec;
+ CHECK( spec.hasFilters() == false );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ }
+
+ SECTION( "Test spec from empty string should have no filters" ) {
+ TestSpec spec = parseTestSpec( "" );
+ CHECK( spec.hasFilters() == false );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ }
+
+ SECTION( "Test spec from just a comma should have no filters" ) {
+ TestSpec spec = parseTestSpec( "," );
+ CHECK( spec.hasFilters() == false );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ }
+
+ SECTION( "Test spec from name should have one filter" ) {
+ TestSpec spec = parseTestSpec( "b" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == true );
+ }
+
+ SECTION( "Test spec from quoted name should have one filter" ) {
+ TestSpec spec = parseTestSpec( "\"b\"" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == true );
+ }
+
+ SECTION( "Test spec from name should have one filter" ) {
+ TestSpec spec = parseTestSpec( "b" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == false );
+ }
+
+ SECTION( "Wildcard at the start" ) {
+ TestSpec spec = parseTestSpec( "*spaces" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == false );
+ CHECK( parseTestSpec( "*a" ).matches( *tcA ) == true );
+ }
+ SECTION( "Wildcard at the end" ) {
+ TestSpec spec = parseTestSpec( "long*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == false );
+ CHECK( parseTestSpec( "a*" ).matches( *tcA ) == true );
+ }
+ SECTION( "Wildcard at both ends" ) {
+ TestSpec spec = parseTestSpec( "*name*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == true );
+ CHECK( parseTestSpec( "*a*" ).matches( *tcA ) == true );
+ }
+ SECTION( "Redundant wildcard at the start" ) {
+ TestSpec spec = parseTestSpec( "*a" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == false );
+ }
+ SECTION( "Redundant wildcard at the end" ) {
+ TestSpec spec = parseTestSpec( "a*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == false );
+ }
+ SECTION( "Redundant wildcard at both ends" ) {
+ TestSpec spec = parseTestSpec( "*a*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == false );
+ }
+ SECTION( "Wildcard at both ends, redundant at start" ) {
+ TestSpec spec = parseTestSpec( "*longer*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == true );
+ }
+ SECTION( "Just wildcard" ) {
+ TestSpec spec = parseTestSpec( "*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == true );
+ }
+
+ SECTION( "Single tag" ) {
+ TestSpec spec = parseTestSpec( "[one]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == false );
+ }
+ SECTION( "Single tag, two matches" ) {
+ TestSpec spec = parseTestSpec( "[x]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == true );
+ }
+ SECTION( "Two tags" ) {
+ TestSpec spec = parseTestSpec( "[two][x]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ }
+ SECTION( "Two tags, spare separated" ) {
+ TestSpec spec = parseTestSpec( "[two] [x]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ }
+ SECTION( "Wildcarded name and tag" ) {
+ TestSpec spec = parseTestSpec( "*name*[x]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == false );
+ }
+ SECTION( "Single tag exclusion" ) {
+ TestSpec spec = parseTestSpec( "~[one]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == false );
+ }
+ SECTION( "One tag exclusion and one tag inclusion" ) {
+ TestSpec spec = parseTestSpec( "~[two][x]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == false );
+ }
+ SECTION( "One tag exclusion and one wldcarded name inclusion" ) {
+ TestSpec spec = parseTestSpec( "~[two]*name*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == false );
+ CHECK( spec.matches( *tcD ) == true );
+ }
+ SECTION( "One tag exclusion, using exclude:, and one wldcarded name inclusion" ) {
+ TestSpec spec = parseTestSpec( "exclude:[two]*name*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == false );
+ CHECK( spec.matches( *tcD ) == true );
+ }
+ SECTION( "name exclusion" ) {
+ TestSpec spec = parseTestSpec( "~b" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == false );
+ CHECK( spec.matches( *tcD ) == true );
+ }
+ SECTION( "wildcarded name exclusion" ) {
+ TestSpec spec = parseTestSpec( "~*name*" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == false );
+ CHECK( spec.matches( *tcD ) == false );
+ }
+ SECTION( "wildcarded name exclusion with tag inclusion" ) {
+ TestSpec spec = parseTestSpec( "~*name*,[three]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == false );
+ }
+ SECTION( "wildcarded name exclusion, using exclude:, with tag inclusion" ) {
+ TestSpec spec = parseTestSpec( "exclude:*name*,[three]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == true );
+ CHECK( spec.matches( *tcB ) == true );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == false );
+ }
+ SECTION( "two wildcarded names" ) {
+ TestSpec spec = parseTestSpec( "\"longer*\"\"*spaces\"" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == true );
+ CHECK( spec.matches( *tcD ) == false );
+ }
+ SECTION( "empty tag" ) {
+ TestSpec spec = parseTestSpec( "[]" );
+ CHECK( spec.hasFilters() == false );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == false );
+ CHECK( spec.matches( *tcD ) == false );
+ }
+ SECTION( "empty quoted name" ) {
+ TestSpec spec = parseTestSpec( "\"\"" );
+ CHECK( spec.hasFilters() == false );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == false );
+ CHECK( spec.matches( *tcD ) == false );
+ }
+ SECTION( "quoted string followed by tag exclusion" ) {
+ TestSpec spec = parseTestSpec( "\"*name*\"~[.]" );
+ CHECK( spec.hasFilters() == true );
+ CHECK( spec.matches( *tcA ) == false );
+ CHECK( spec.matches( *tcB ) == false );
+ CHECK( spec.matches( *tcC ) == false );
+ CHECK( spec.matches( *tcD ) == true );
+ }
+ SECTION( "Leading and trailing spaces in test spec" ) {
+ TestSpec spec = parseTestSpec( "\" aardvark \"" );
+ CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
+ CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) );
+ CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
+ CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) );
+ CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) );
+
+ }
+ SECTION( "Leading and trailing spaces in test name" ) {
+ TestSpec spec = parseTestSpec( "aardvark" );
+ CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
+ CHECK( spec.matches( *fakeTestCase( " aardvark" ) ) );
+ CHECK( spec.matches( *fakeTestCase( " aardvark " ) ) );
+ CHECK( spec.matches( *fakeTestCase( "aardvark " ) ) );
+ CHECK( spec.matches( *fakeTestCase( "aardvark" ) ) );
+ }
+ SECTION("Shortened hide tags are split apart when parsing") {
+ TestSpec spec = parseTestSpec("[.foo]");
+ CHECK(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")));
+ CHECK_FALSE(spec.matches(*fakeTestCase("only foo", "[foo]")));
+ }
+ SECTION("Shortened hide tags also properly handle exclusion") {
+ TestSpec spec = parseTestSpec("~[.foo]");
+ CHECK_FALSE(spec.matches(*fakeTestCase("hidden and foo", "[.][foo]")));
+ CHECK_FALSE(spec.matches(*fakeTestCase("only foo", "[foo]")));
+ CHECK_FALSE(spec.matches(*fakeTestCase("only hidden", "[.]")));
+ CHECK(spec.matches(*fakeTestCase("neither foo nor hidden", "[bar]")));
+ }
+}
+
+TEST_CASE("#1905 -- test spec parser properly clears internal state between compound tests", "[command-line][test-spec]") {
+ using Catch::parseTestSpec;
+ using Catch::TestSpec;
+ // We ask for one of 2 different tests and the latter one of them has a , in name that needs escaping
+ TestSpec spec = parseTestSpec(R"("spec . char","spec \, char")");
+
+ REQUIRE(spec.matches(*fakeTestCase("spec . char")));
+ REQUIRE(spec.matches(*fakeTestCase("spec , char")));
+ REQUIRE_FALSE(spec.matches(*fakeTestCase(R"(spec \, char)")));
+}
+
+TEST_CASE("#1912 -- test spec parser handles escaping", "[command-line][test-spec]") {
+ using Catch::parseTestSpec;
+ using Catch::TestSpec;
+
+ SECTION("Various parentheses") {
+ TestSpec spec = parseTestSpec(R"(spec {a} char,spec \[a] char)");
+
+ REQUIRE(spec.matches(*fakeTestCase(R"(spec {a} char)")));
+ REQUIRE(spec.matches(*fakeTestCase(R"(spec [a] char)")));
+ REQUIRE_FALSE(spec.matches(*fakeTestCase("differs but has similar tag", "[a]")));
+ }
+ SECTION("backslash in test name") {
+ TestSpec spec = parseTestSpec(R"(spec \\ char)");
+
+ REQUIRE(spec.matches(*fakeTestCase(R"(spec \ char)")));
+ }
+}
+
+TEST_CASE("Test spec serialization is round-trippable", "[test-spec][serialization][approvals]") {
+ using Catch::parseTestSpec;
+ using Catch::TestSpec;
+
+ auto serializedTestSpec = []( std::string const& spec ) {
+ Catch::ReusableStringStream sstr;
+ sstr << parseTestSpec( spec );
+ return sstr.str();
+ };
+
+ SECTION("Spaces are normalized") {
+ CHECK( serializedTestSpec( "[abc][def]" ) == "[abc] [def]" );
+ CHECK( serializedTestSpec( "[def] [abc]" ) == "[def] [abc]" );
+ CHECK( serializedTestSpec( "[def] [abc]" ) == "[def] [abc]" );
+ }
+ SECTION("Output is order dependent") {
+ CHECK( serializedTestSpec( "[abc][def]" ) == "[abc] [def]" );
+ CHECK( serializedTestSpec( "[def][abc]" ) == "[def] [abc]" );
+ }
+ SECTION("Multiple disjunct filters") {
+ CHECK( serializedTestSpec( "[abc],[def]" ) == "[abc],[def]" );
+ CHECK( serializedTestSpec( "[def],[abc],[idkfa]" ) == "[def],[abc],[idkfa]" );
+ }
+ SECTION("Test names are enclosed in string") {
+ CHECK( serializedTestSpec( "Some test" ) == "\"Some test\"" );
+ CHECK( serializedTestSpec( "*Some test" ) == "\"*Some test\"" );
+ CHECK( serializedTestSpec( "* Some test" ) == "\"* Some test\"" );
+ CHECK( serializedTestSpec( "* Some test *" ) == "\"* Some test *\"" );
+ }
+ SECTION( "Mixing test names and tags" ) {
+ CHECK( serializedTestSpec( "some test[abcd]" ) ==
+ "\"some test\" [abcd]" );
+ CHECK( serializedTestSpec( "[ab]some test[cd]" ) ==
+ "[ab] \"some test\" [cd]" );
+ }
+}
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp
index c8ac77b293aaa0ec230fcef7b701ec8d71be7c46..ae27b40668ae5dd20ff77de61bc3720956d53e8b 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/TextFlow.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TextFlow.tests.cpp
index 379dc624dace6ce1f188220107c809f6598f2af7..82de5a27f5c936df9dfae3186563ea96c5d766ec 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/TextFlow.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/TextFlow.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp
index 63f072dd9940c5489938b6ddb8fdddcd40dd688a..e50e4c5e717c40bbab10f064894f3aa412a1a7ae 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/ToString.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Traits.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Traits.tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..459e0d4857a07c06ebabfa68def8a893a15b3b88
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Traits.tests.cpp
@@ -0,0 +1,45 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/internal/catch_compare_traits.hpp>
+#include <helpers/type_with_lit_0_comparisons.hpp>
+
+
+#define ADD_TRAIT_TEST_CASE( op ) \
+ TEST_CASE( "is_" #op "_comparable", \
+ "[traits][is_comparable][approvals]" ) { \
+ using Catch::Detail::is_##op##_0_comparable; \
+ using Catch::Detail::is_##op##_comparable; \
+ \
+ STATIC_REQUIRE( is_##op##_comparable<int, int>::value ); \
+ STATIC_REQUIRE( \
+ is_##op##_comparable<std::string, std::string>::value ); \
+ STATIC_REQUIRE( !is_##op##_comparable<int, std::string>::value ); \
+ STATIC_REQUIRE( \
+ !is_##op##_comparable<TypeWithLit0Comparisons, int>::value ); \
+ STATIC_REQUIRE( \
+ !is_##op##_comparable<int, TypeWithLit0Comparisons>::value ); \
+ \
+ STATIC_REQUIRE( is_##op##_0_comparable<int>::value ); \
+ STATIC_REQUIRE( \
+ is_##op##_0_comparable<TypeWithLit0Comparisons>::value ); \
+ STATIC_REQUIRE( !is_##op##_0_comparable<std::string>::value ); \
+ \
+ /* This test fails with MSVC in permissive mode, because of course it does */ \
+ /* STATIC_REQUIRE( !is_##op##_0_comparable<int*>::value ); */ \
+}
+
+ADD_TRAIT_TEST_CASE(lt)
+ADD_TRAIT_TEST_CASE(gt)
+ADD_TRAIT_TEST_CASE(le)
+ADD_TRAIT_TEST_CASE(ge)
+ADD_TRAIT_TEST_CASE(eq)
+ADD_TRAIT_TEST_CASE(ne)
+
+#undef ADD_TRAIT_TEST_CASE
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/UniquePtr.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/UniquePtr.tests.cpp
index 40c9886c32cadd680265923ed518d68164295a9d..420bf1b34fdbc49145777b6cea2470b0cbd64352 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/UniquePtr.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/UniquePtr.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Xml.tests.cpp b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Xml.tests.cpp
index 9fe9416a121485918ba5835313482972df68cbf3..b5982b8551763f5a8f3564aff28c0a1b4c002e6f 100644
--- a/packages/Catch2/tests/SelfTest/IntrospectiveTests/Xml.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/IntrospectiveTests/Xml.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/TestRegistrations.cpp b/packages/Catch2/tests/SelfTest/TestRegistrations.cpp
index f24c913f5d0ca575796b7b3b966b45f2d78c3ffa..6476773529c798ccb68853faab27f4622eabdcbb 100644
--- a/packages/Catch2/tests/SelfTest/TestRegistrations.cpp
+++ b/packages/Catch2/tests/SelfTest/TestRegistrations.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/TimingTests/Sleep.tests.cpp b/packages/Catch2/tests/SelfTest/TimingTests/Sleep.tests.cpp
index bfb222d037c078225c171f747256065c2813a876..4e9e385b23176d5a5ca527bbedf105cc8345a50a 100644
--- a/packages/Catch2/tests/SelfTest/TimingTests/Sleep.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/TimingTests/Sleep.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Approx.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Approx.tests.cpp
index 853227a2783db138362fca899e3a340323971fe0..c3d41cb4463c86e5d3d2b791b6c1e9fd9f9b0061 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Approx.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Approx.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/BDD.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/BDD.tests.cpp
index b128196c3e4da62ed3d7a7970de1b332e014920a..5ac860553b47a7f0f03444c3d0abc5451ac0bf41 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/BDD.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/BDD.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Benchmark.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Benchmark.tests.cpp
index ffedc9a2f65cfe11ef4384119bb455725d2406d6..557b2131c6285acea373acc18850027fcbc47d55 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Benchmark.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Benchmark.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -16,21 +16,23 @@
namespace {
std::uint64_t Fibonacci(std::uint64_t number) {
- return number < 2 ? 1 : Fibonacci(number - 1) + Fibonacci(number - 2);
+ return number < 2 ? number : Fibonacci(number - 1) + Fibonacci(number - 2);
}
}
TEST_CASE("Benchmark Fibonacci", "[!benchmark]") {
- CHECK(Fibonacci(0) == 1);
+ CHECK(Fibonacci(0) == 0);
// some more asserts..
- CHECK(Fibonacci(5) == 8);
+ CHECK(Fibonacci(5) == 5);
// some more asserts..
- BENCHMARK("Fibonacci 20") {
+ REQUIRE( Fibonacci( 20 ) == 6'765 );
+ BENCHMARK( "Fibonacci 20" ) {
return Fibonacci(20);
};
- BENCHMARK("Fibonacci 25") {
+ REQUIRE( Fibonacci( 25 ) == 75'025 );
+ BENCHMARK( "Fibonacci 25" ) {
return Fibonacci(25);
};
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Class.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Class.tests.cpp
index 6b2ba4cfe6559ff6f9f794130d912cc8725a6ee2..bab7a684379330e43a85a38404616195e1c34430 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Class.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Class.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Compilation.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Compilation.tests.cpp
index 5d9ab3f05975113d7b132c4ab6b9ca4e3bba9804..1cdcfb788ec1a8a82c0ff8e5d3a6121b7e2f9cfd 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Compilation.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Compilation.tests.cpp
@@ -1,11 +1,13 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
+#include <helpers/type_with_lit_0_comparisons.hpp>
+
#include <type_traits>
// Setup for #1403 -- look for global overloads of operator << for classes
@@ -310,3 +312,44 @@ TEST_CASE("ADL universal operators don't hijack expression deconstruction", "[co
REQUIRE(0 & adl::always_true{});
REQUIRE(0 ^ adl::always_true{});
}
+
+TEST_CASE( "#2555 - types that can only be compared with 0 literal (not int/long) are supported", "[compilation][approvals]" ) {
+ REQUIRE( TypeWithLit0Comparisons{} < 0 );
+ REQUIRE_FALSE( 0 < TypeWithLit0Comparisons{} );
+ REQUIRE( TypeWithLit0Comparisons{} <= 0 );
+ REQUIRE_FALSE( 0 > TypeWithLit0Comparisons{} );
+
+ REQUIRE( TypeWithLit0Comparisons{} > 0 );
+ REQUIRE_FALSE( 0 > TypeWithLit0Comparisons{} );
+ REQUIRE( TypeWithLit0Comparisons{} >= 0 );
+ REQUIRE_FALSE( 0 >= TypeWithLit0Comparisons{} );
+
+ REQUIRE( TypeWithLit0Comparisons{} == 0 );
+ REQUIRE_FALSE( 0 == TypeWithLit0Comparisons{} );
+ REQUIRE( TypeWithLit0Comparisons{} != 0 );
+ REQUIRE_FALSE( 0 != TypeWithLit0Comparisons{} );
+}
+
+namespace {
+ struct MultipleImplicitConstructors {
+ MultipleImplicitConstructors( double ) {}
+ MultipleImplicitConstructors( int64_t ) {}
+ bool operator==( MultipleImplicitConstructors ) const { return true; }
+ bool operator!=( MultipleImplicitConstructors ) const { return true; }
+ bool operator<( MultipleImplicitConstructors ) const { return true; }
+ bool operator<=( MultipleImplicitConstructors ) const { return true; }
+ bool operator>( MultipleImplicitConstructors ) const { return true; }
+ bool operator>=( MultipleImplicitConstructors ) const { return true; }
+ };
+}
+TEST_CASE("#2571 - tests compile types that have multiple implicit constructors from lit 0",
+ "[compilation][approvals]") {
+ MultipleImplicitConstructors mic1( 0.0 );
+ MultipleImplicitConstructors mic2( 0.0 );
+ REQUIRE( mic1 == mic2 );
+ REQUIRE( mic1 != mic2 );
+ REQUIRE( mic1 < mic2 );
+ REQUIRE( mic1 <= mic2 );
+ REQUIRE( mic1 > mic2 );
+ REQUIRE( mic1 >= mic2 );
+}
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Condition.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Condition.tests.cpp
index 2e3b624e1d21db24eaa9ef38c0aa6fb3f8974b6d..211dd3b9152905b1e6ec7d10abaad617b9903be6 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Condition.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Condition.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Decomposition.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Decomposition.tests.cpp
index 0a169831729d27e26982ef9b9fb79ad3a26df9c8..e92f740606095d9f48b18c074853a4e6bb3b5bae 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Decomposition.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Decomposition.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -34,6 +34,8 @@ TEST_CASE( "Reconstruction should be based on stringification: #914" , "[Decompo
TEST_CASE("#1005: Comparing pointer to int and long (NULL can be either on various systems)", "[Decomposition][approvals]") {
FILE* fptr = nullptr;
- REQUIRE(fptr == 0);
- REQUIRE(fptr == 0l);
+ REQUIRE( fptr == 0 );
+ REQUIRE_FALSE( fptr != 0 );
+ REQUIRE( fptr == 0l );
+ REQUIRE_FALSE( fptr != 0l );
}
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/EnumToString.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/EnumToString.tests.cpp
index 7cf6213733259437232251918aaa5fc91ccec784..362cf8046d2deeaf56b2ad69df359fe47314c837 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/EnumToString.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/EnumToString.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Exception.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Exception.tests.cpp
index e93cf91930ea79131cdd0885215d48f95bf2ac4c..4f91a30c47fb26cd90454e37423b8811b49c59da 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Exception.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Exception.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -20,7 +20,7 @@
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"
#pragma clang diagnostic ignored "-Wmissing-noreturn"
-#pragma clang diagnostic ignored "-Wunreachable-code"
+#pragma clang diagnostic ignored "-Wunreachable-code-return"
#endif
namespace {
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Generators.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Generators.tests.cpp
index 5b205c85c773125ef9179dc80795c8e389e4fd79..8e2c387a304e6838e48ac648a93bbeb9a8af3e15 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Generators.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Generators.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -261,6 +261,10 @@ TEST_CASE("Copy and then generate a range", "[generators]") {
}
}
+#if defined( __clang__ )
+# pragma clang diagnostic pop
+#endif
+
TEST_CASE("#1913 - GENERATE inside a for loop should not keep recreating the generator", "[regression][generators]") {
static int counter = 0;
for (int i = 0; i < 3; ++i) {
@@ -277,6 +281,33 @@ TEST_CASE("#1913 - GENERATEs can share a line", "[regression][generators]") {
REQUIRE(i != j);
}
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif
+namespace {
+ class test_generator : public Catch::Generators::IGenerator<int> {
+ public:
+ [[noreturn]] explicit test_generator() {
+ // removing the following line will cause the program to terminate
+ // gracefully.
+ throw Catch::GeneratorException( "failure to init" );
+ }
+
+ auto get() const -> int const& override {
+ static constexpr int value = 1;
+ return value;
+ }
+
+ auto next() -> bool override { return false; }
+ };
+
+ static auto make_test_generator()
+ -> Catch::Generators::GeneratorWrapper<int> {
+ return { new test_generator() };
+ }
+
+} // namespace
+
+TEST_CASE( "#2615 - Throwing in constructor generator fails test case but does not abort", "[!shouldfail]" ) {
+ // this should fail the test case, but not abort the application
+ auto sample = GENERATE( make_test_generator() );
+ // this assertion shouldn't trigger
+ REQUIRE( sample == 0 );
+}
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Matchers.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Matchers.tests.cpp
index 5b4e9e033ff2214fd4b3f2fc356ab9316174e921..74bedf5ea97b05b931cd3282ea6aa4cdffc32f38 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Matchers.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Matchers.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -406,6 +406,25 @@ TEST_CASE( "Vector matchers that fail", "[matchers][vector][.][failing]" ) {
}
}
+namespace {
+ struct SomeType {
+ int i;
+ friend bool operator==( SomeType lhs, SomeType rhs ) {
+ return lhs.i == rhs.i;
+ }
+ };
+} // end anonymous namespace
+
+TEST_CASE( "Vector matcher with elements without !=", "[matchers][vector][approvals]" ) {
+ std::vector<SomeType> lhs, rhs;
+ lhs.push_back( { 1 } );
+ lhs.push_back( { 2 } );
+ rhs.push_back( { 1 } );
+ rhs.push_back( { 1 } );
+
+ REQUIRE_THAT( lhs, !Equals(rhs) );
+}
+
TEST_CASE( "Exception matchers that succeed",
"[matchers][exceptions][!throws]" ) {
CHECK_THROWS_MATCHES(
@@ -497,6 +516,9 @@ TEST_CASE( "Floating point matchers: float", "[matchers][floating-point]" ) {
REQUIRE_THROWS_AS( WithinRel( 1.f, -0.2f ), std::domain_error );
REQUIRE_THROWS_AS( WithinRel( 1.f, 1.f ), std::domain_error );
}
+ SECTION( "IsNaN" ) {
+ REQUIRE_THAT( 1., !IsNaN() );
+ }
}
TEST_CASE( "Floating point matchers: double", "[matchers][floating-point]" ) {
@@ -552,6 +574,9 @@ TEST_CASE( "Floating point matchers: double", "[matchers][floating-point]" ) {
REQUIRE_THROWS_AS( WithinRel( 1., -0.2 ), std::domain_error );
REQUIRE_THROWS_AS( WithinRel( 1., 1. ), std::domain_error );
}
+ SECTION("IsNaN") {
+ REQUIRE_THAT( 1., !IsNaN() );
+ }
}
TEST_CASE( "Floating point matchers that are problematic in approvals",
@@ -566,6 +591,8 @@ TEST_CASE( "Floating point matchers that are problematic in approvals",
REQUIRE_THAT( NAN, !WithinRel( NAN ) );
REQUIRE_THAT( 1., !WithinRel( NAN ) );
REQUIRE_THAT( NAN, !WithinRel( 1. ) );
+ REQUIRE_THAT( NAN, IsNaN() );
+ REQUIRE_THAT( static_cast<double>(NAN), IsNaN() );
}
TEST_CASE( "Arbitrary predicate matcher", "[matchers][generic]" ) {
@@ -660,6 +687,21 @@ TEST_CASE( "Exceptions matchers", "[matchers][exceptions][!throws]" ) {
Message( "SpecialException::what" ) );
}
+TEST_CASE( "Exception message can be matched", "[matchers][exceptions][!throws]" ) {
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(),
+ DerivedException,
+ MessageMatches( StartsWith( "Derived" ) ) );
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(),
+ DerivedException,
+ MessageMatches( EndsWith( "::what" ) ) );
+ REQUIRE_THROWS_MATCHES( throwsDerivedException(),
+ DerivedException,
+ MessageMatches( !StartsWith( "::what" ) ) );
+ REQUIRE_THROWS_MATCHES( throwsSpecialException( 2 ),
+ SpecialException,
+ MessageMatches( StartsWith( "Special" ) ) );
+}
+
struct CheckedTestingMatcher : Catch::Matchers::MatcherBase<int> {
mutable bool matchCalled = false;
bool matchSucceeds = false;
@@ -848,7 +890,7 @@ struct MatcherA : Catch::Matchers::MatcherGenericBase {
return "equals: (int) 1 or (string) \"1\"";
}
bool match( int i ) const { return i == 1; }
- bool match( std::string s ) const { return s == "1"; }
+ bool match( std::string const& s ) const { return s == "1"; }
};
struct MatcherB : Catch::Matchers::MatcherGenericBase {
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
index 1201581cf1a5006e747d4041d891f8f094d2daf4..cc8c54f8bf0bcdc0f031955d67bfa46f98ea6e54 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -9,200 +9,21 @@
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_container_properties.hpp>
#include <catch2/matchers/catch_matchers_contains.hpp>
+#include <catch2/matchers/catch_matchers_range_equals.hpp>
#include <catch2/matchers/catch_matchers_floating_point.hpp>
#include <catch2/matchers/catch_matchers_quantifiers.hpp>
#include <catch2/matchers/catch_matchers_predicate.hpp>
#include <catch2/matchers/catch_matchers_string.hpp>
+#include <helpers/range_test_helpers.hpp>
+
#include <cmath>
-#include <initializer_list>
#include <list>
#include <map>
#include <type_traits>
#include <vector>
#include <memory>
-namespace {
-
-namespace unrelated {
- template <typename T>
- class needs_ADL_begin {
- std::vector<T> m_elements;
- public:
- using iterator = typename std::vector<T>::iterator;
- using const_iterator = typename std::vector<T>::const_iterator;
-
- needs_ADL_begin(std::initializer_list<T> init) : m_elements(init) {}
-
- const_iterator Begin() const { return m_elements.begin(); }
- const_iterator End() const { return m_elements.end(); }
-
- friend const_iterator begin(needs_ADL_begin const& lhs) {
- return lhs.Begin();
- }
- friend const_iterator end(needs_ADL_begin const& rhs) {
- return rhs.End();
- }
- };
-} // end unrelated namespace
-
-#if defined(__clang__)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wunused-function"
-#endif
-
-template <typename T>
-class has_different_begin_end_types {
- // Using std::vector<T> leads to annoying issues when T is bool
- // so we just use list because the perf is not critical and ugh.
- std::list<T> m_elements;
-
- // Different type for the "end" iterator
- struct iterator_end {};
- // Fake-ish forward iterator that only compares to a different type
- class iterator {
- using underlying_iter = typename std::list<T>::const_iterator;
- underlying_iter m_start;
- underlying_iter m_end;
-
- public:
- iterator( underlying_iter start, underlying_iter end ):
- m_start( start ), m_end( end ) {}
-
- using iterator_category = std::forward_iterator_tag;
- using difference_type = std::ptrdiff_t;
- using value_type = T;
- using const_reference = T const&;
- using pointer = T const*;
-
-
- friend bool operator==( iterator iter, iterator_end ) {
- return iter.m_start == iter.m_end;
- }
- friend bool operator!=( iterator iter, iterator_end ) {
- return iter.m_start != iter.m_end;
- }
- iterator& operator++() {
- ++m_start;
- return *this;
- }
- iterator operator++(int) {
- auto tmp(*this);
- ++m_start;
- return tmp;
- }
- const_reference operator*() const {
- return *m_start;
- }
- pointer operator->() const {
- return m_start;
- }
- };
-
-
-public:
- explicit has_different_begin_end_types( std::initializer_list<T> init ):
- m_elements( init ) {}
-
- iterator begin() const {
- return { m_elements.begin(), m_elements.end() };
- }
-
- iterator_end end() const {
- return {};
- }
-};
-
-#if defined(__clang__)
-# pragma clang diagnostic pop
-#endif
-
-template <typename T> struct with_mocked_iterator_access {
- std::vector<T> m_elements;
-
- // use plain arrays to have nicer printouts with CHECK(...)
- mutable std::unique_ptr<bool[]> m_derefed;
-
- // We want to check which elements were dereferenced when iterating, so
- // we can check whether iterator-using code traverses range correctly
- template <bool is_const> class basic_iterator {
- template <typename U>
- using constify_t = std::conditional_t<is_const, std::add_const_t<U>, U>;
-
- constify_t<with_mocked_iterator_access>* m_origin;
- size_t m_origin_idx;
-
- public:
- using iterator_category = std::forward_iterator_tag;
- using difference_type = std::ptrdiff_t;
- using value_type = constify_t<T>;
- using const_reference = typename std::vector<T>::const_reference;
- using reference = typename std::vector<T>::reference;
- using pointer = typename std::vector<T>::pointer;
-
- basic_iterator( constify_t<with_mocked_iterator_access>* origin,
- std::size_t origin_idx ):
- m_origin{ origin }, m_origin_idx{ origin_idx } {}
-
- friend bool operator==( basic_iterator lhs, basic_iterator rhs ) {
- return lhs.m_origin == rhs.m_origin &&
- lhs.m_origin_idx == rhs.m_origin_idx;
- }
- friend bool operator!=( basic_iterator lhs, basic_iterator rhs ) {
- return !( lhs == rhs );
- }
- basic_iterator& operator++() {
- ++m_origin_idx;
- return *this;
- }
- basic_iterator operator++( int ) {
- auto tmp( *this );
- ++( *this );
- return tmp;
- }
- const_reference operator*() const {
- assert( m_origin_idx < m_origin->m_elements.size() && "Attempted to deref invalid position" );
- m_origin->m_derefed[m_origin_idx] = true;
- return m_origin->m_elements[m_origin_idx];
- }
- pointer operator->() const {
- assert( m_origin_idx < m_origin->m_elements.size() && "Attempted to deref invalid position" );
- return &m_origin->m_elements[m_origin_idx];
- }
- };
-
- using iterator = basic_iterator<false>;
- using const_iterator = basic_iterator<true>;
-
- with_mocked_iterator_access( std::initializer_list<T> init ):
- m_elements( init ),
- m_derefed( std::make_unique<bool[]>( m_elements.size() ) ) {}
-
- const_iterator begin() const { return { this, 0 }; }
- const_iterator end() const { return { this, m_elements.size() }; }
- iterator begin() { return { this, 0 }; }
- iterator end() { return { this, m_elements.size() }; }
-};
-
-} // end anon namespace
-
-namespace Catch {
- // make sure with_mocked_iterator_access is not considered a range by Catch,
- // so that below StringMaker is used instead of the default one for ranges
- template <typename T>
- struct is_range<with_mocked_iterator_access<T>> : std::false_type {};
-
- template <typename T>
- struct StringMaker<with_mocked_iterator_access<T>> {
- static std::string
- convert( with_mocked_iterator_access<T> const& access ) {
- // We have to avoid the type's iterators, because we check
- // their use in tests
- return ::Catch::Detail::stringify( access.m_elements );
- }
- };
-} // namespace Catch
-
struct MoveOnlyTestElement {
int num = 0;
MoveOnlyTestElement(int n) :num(n) {}
@@ -286,16 +107,6 @@ namespace {
bool empty() const { return false; }
};
-namespace unrelated {
- struct ADL_empty {
- bool Empty() const { return true; }
-
- friend bool empty(ADL_empty e) {
- return e.Empty();
- }
- };
-
-} // end namespace unrelated
} // end unnamed namespace
TEST_CASE("Basic use of the Empty range matcher", "[matchers][templated][empty]") {
@@ -345,17 +156,6 @@ namespace {
return LessThanMatcher{ sz };
}
- namespace unrelated {
- struct ADL_size {
- size_t sz() const {
- return 12;
- }
- friend size_t size(ADL_size s) {
- return s.sz();
- }
- };
- } // end namespace unrelated
-
struct has_size {
size_t size() const {
return 13;
@@ -581,7 +381,7 @@ TEST_CASE("Usage of AllTrue range matcher", "[matchers][templated][quantifiers]"
std::array<bool, 0> const data{};
REQUIRE_THAT( data, AllTrue() );
}
- SECTION( "One false evalutes to false" ) {
+ SECTION( "One false evaluates to false" ) {
std::array<bool, 5> const data{ { true, true, false, true, true } };
REQUIRE_THAT( data, !AllTrue() );
}
@@ -598,7 +398,7 @@ TEST_CASE("Usage of AllTrue range matcher", "[matchers][templated][quantifiers]"
{ { true }, { true }, { true }, { true }, { true } } };
REQUIRE_THAT( data, AllTrue() );
}
- SECTION( "One false evalutes to false" ) {
+ SECTION( "One false evaluates to false" ) {
std::array<ConvertibleToBool, 5> const data{
{ { true }, { true }, { false }, { true }, { true } } };
REQUIRE_THAT( data, !AllTrue() );
@@ -646,7 +446,7 @@ TEST_CASE( "Usage of NoneTrue range matcher", "[matchers][templated][quantifiers
std::array<bool, 0> const data{};
REQUIRE_THAT( data, NoneTrue() );
}
- SECTION( "One true evalutes to false" ) {
+ SECTION( "One true evaluates to false" ) {
std::array<bool, 5> const data{
{ false, false, true, false, false } };
REQUIRE_THAT( data, !NoneTrue() );
@@ -664,7 +464,7 @@ TEST_CASE( "Usage of NoneTrue range matcher", "[matchers][templated][quantifiers
{ { true }, { true }, { true }, { true }, { true } } };
REQUIRE_THAT( data, !NoneTrue() );
}
- SECTION( "One true evalutes to false" ) {
+ SECTION( "One true evaluates to false" ) {
std::array<ConvertibleToBool, 5> const data{
{ { false }, { false }, { true }, { false }, { false } } };
REQUIRE_THAT( data, !NoneTrue() );
@@ -712,7 +512,7 @@ TEST_CASE( "Usage of AnyTrue range matcher", "[matchers][templated][quantifiers]
std::array<bool, 0> const data{};
REQUIRE_THAT( data, !AnyTrue() );
}
- SECTION( "One true evalutes to true" ) {
+ SECTION( "One true evaluates to true" ) {
std::array<bool, 5> const data{
{ false, false, true, false, false } };
REQUIRE_THAT( data, AnyTrue() );
@@ -730,7 +530,7 @@ TEST_CASE( "Usage of AnyTrue range matcher", "[matchers][templated][quantifiers]
{ { true }, { true }, { true }, { true }, { true } } };
REQUIRE_THAT( data, AnyTrue() );
}
- SECTION( "One true evalutes to true" ) {
+ SECTION( "One true evaluates to true" ) {
std::array<ConvertibleToBool, 5> const data{
{ { false }, { false }, { true }, { false }, { false } } };
REQUIRE_THAT( data, AnyTrue() );
@@ -831,4 +631,287 @@ TEST_CASE( "The quantifier range matchers support types with different types ret
}
}
+TEST_CASE( "RangeEquals supports ranges with different types returned from begin and end",
+ "[matchers][templated][range][approvals] ") {
+ using Catch::Matchers::RangeEquals;
+ using Catch::Matchers::UnorderedRangeEquals;
+
+ has_different_begin_end_types<int> diff_types{ 1, 2, 3, 4, 5 };
+ std::array<int, 5> arr1{ { 1, 2, 3, 4, 5 } }, arr2{ { 2, 3, 4, 5, 6 } };
+
+ REQUIRE_THAT( diff_types, RangeEquals( arr1 ) );
+ REQUIRE_THAT( diff_types, RangeEquals( arr2, []( int l, int r ) {
+ return l + 1 == r;
+ } ) );
+ REQUIRE_THAT( diff_types, UnorderedRangeEquals( diff_types ) );
+}
+
+TEST_CASE( "RangeContains supports ranges with different types returned from "
+ "begin and end",
+ "[matchers][templated][range][approvals]" ) {
+ using Catch::Matchers::Contains;
+
+ has_different_begin_end_types<size_t> diff_types{ 1, 2, 3, 4, 5 };
+ REQUIRE_THAT( diff_types, Contains( size_t( 3 ) ) );
+ REQUIRE_THAT( diff_types, Contains( LessThanMatcher( size_t( 4 ) ) ) );
+}
+
#endif
+
+TEST_CASE( "Usage of RangeEquals range matcher", "[matchers][templated][quantifiers]" ) {
+ using Catch::Matchers::RangeEquals;
+
+ // In these tests, the types are always the same - type conversion is in the next section
+ SECTION( "Basic usage" ) {
+ SECTION( "Empty container matches empty container" ) {
+ const std::vector<int> empty_vector;
+ CHECK_THAT( empty_vector, RangeEquals( empty_vector ) );
+ }
+ SECTION( "Empty container does not match non-empty container" ) {
+ const std::vector<int> empty_vector;
+ const std::vector<int> non_empty_vector{ 1 };
+ CHECK_THAT( empty_vector, !RangeEquals( non_empty_vector ) );
+ // ...and in reverse
+ CHECK_THAT( non_empty_vector, !RangeEquals( empty_vector ) );
+ }
+ SECTION( "Two equal 1-length non-empty containers" ) {
+ const std::array<int, 1> non_empty_array{ { 1 } };
+ CHECK_THAT( non_empty_array, RangeEquals( non_empty_array ) );
+ }
+ SECTION( "Two equal-sized, equal, non-empty containers" ) {
+ const std::array<int, 3> array_a{ { 1, 2, 3 } };
+ CHECK_THAT( array_a, RangeEquals( array_a ) );
+ }
+ SECTION( "Two equal-sized, non-equal, non-empty containers" ) {
+ const std::array<int, 3> array_a{ { 1, 2, 3 } };
+ const std::array<int, 3> array_b{ { 2, 2, 3 } };
+ const std::array<int, 3> array_c{ { 1, 2, 2 } };
+ CHECK_THAT( array_a, !RangeEquals( array_b ) );
+ CHECK_THAT( array_a, !RangeEquals( array_c ) );
+ }
+ SECTION( "Two non-equal-sized, non-empty containers (with same first "
+ "elements)" ) {
+ const std::vector<int> vector_a{ 1, 2, 3 };
+ const std::vector<int> vector_b{ 1, 2, 3, 4 };
+ CHECK_THAT( vector_a, !RangeEquals( vector_b ) );
+ }
+ }
+
+ SECTION( "Custom predicate" ) {
+
+ auto close_enough = []( int lhs, int rhs ) {
+ return std::abs( lhs - rhs ) <= 1;
+ };
+
+ SECTION( "Two equal non-empty containers (close enough)" ) {
+ const std::vector<int> vector_a{ { 1, 2, 3 } };
+ const std::vector<int> vector_a_plus_1{ { 2, 3, 4 } };
+ CHECK_THAT( vector_a, RangeEquals( vector_a_plus_1, close_enough ) );
+ }
+ SECTION( "Two non-equal non-empty containers (close enough)" ) {
+ const std::vector<int> vector_a{ { 1, 2, 3 } };
+ const std::vector<int> vector_b{ { 3, 3, 4 } };
+ CHECK_THAT( vector_a, !RangeEquals( vector_b, close_enough ) );
+ }
+ }
+
+ SECTION( "Ranges that need ADL begin/end" ) {
+ unrelated::needs_ADL_begin<int> const
+ needs_adl1{ 1, 2, 3, 4, 5 },
+ needs_adl2{ 1, 2, 3, 4, 5 },
+ needs_adl3{ 2, 3, 4, 5, 6 };
+
+ REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl2 ) );
+ REQUIRE_THAT( needs_adl1, RangeEquals( needs_adl3, []( int l, int r ) {
+ return l + 1 == r;
+ } ) );
+ }
+
+ SECTION("Check short-circuiting behaviour") {
+ with_mocked_iterator_access<int> const mocked1{ 1, 2, 3, 4 };
+
+ SECTION( "Check short-circuits on failure" ) {
+ std::array<int, 4> arr{ { 1, 2, 4, 4 } };
+
+ REQUIRE_THAT( mocked1, !RangeEquals( arr ) );
+ REQUIRE( mocked1.m_derefed[0] );
+ REQUIRE( mocked1.m_derefed[1] );
+ REQUIRE( mocked1.m_derefed[2] );
+ REQUIRE_FALSE( mocked1.m_derefed[3] );
+ }
+ SECTION("All elements are checked on success") {
+ std::array<int, 4> arr{ { 1, 2, 3, 4 } };
+
+ REQUIRE_THAT( mocked1, RangeEquals( arr ) );
+ REQUIRE( mocked1.m_derefed[0] );
+ REQUIRE( mocked1.m_derefed[1] );
+ REQUIRE( mocked1.m_derefed[2] );
+ REQUIRE( mocked1.m_derefed[3] );
+ }
+ }
+}
+
+TEST_CASE( "Usage of UnorderedRangeEquals range matcher",
+ "[matchers][templated][quantifiers]" ) {
+ using Catch::Matchers::UnorderedRangeEquals;
+
+ // In these tests, the types are always the same - type conversion is in the
+ // next section
+ SECTION( "Basic usage" ) {
+ SECTION( "Empty container matches empty container" ) {
+ const std::vector<int> empty_vector;
+ CHECK_THAT( empty_vector, UnorderedRangeEquals( empty_vector ) );
+ }
+ SECTION( "Empty container does not match non-empty container" ) {
+ const std::vector<int> empty_vector;
+ const std::vector<int> non_empty_vector{ 1 };
+ CHECK_THAT( empty_vector,
+ !UnorderedRangeEquals( non_empty_vector ) );
+ // ...and in reverse
+ CHECK_THAT( non_empty_vector,
+ !UnorderedRangeEquals( empty_vector ) );
+ }
+ SECTION( "Two equal 1-length non-empty containers" ) {
+ const std::array<int, 1> non_empty_array{ { 1 } };
+ CHECK_THAT( non_empty_array,
+ UnorderedRangeEquals( non_empty_array ) );
+ }
+ SECTION( "Two equal-sized, equal, non-empty containers" ) {
+ const std::array<int, 3> array_a{ { 1, 2, 3 } };
+ CHECK_THAT( array_a, UnorderedRangeEquals( array_a ) );
+ }
+ SECTION( "Two equal-sized, non-equal, non-empty containers" ) {
+ const std::array<int, 3> array_a{ { 1, 2, 3 } };
+ const std::array<int, 3> array_b{ { 2, 2, 3 } };
+ CHECK_THAT( array_a, !UnorderedRangeEquals( array_b ) );
+ }
+ SECTION( "Two non-equal-sized, non-empty containers" ) {
+ const std::vector<int> vector_a{ 1, 2, 3 };
+ const std::vector<int> vector_b{ 1, 2, 3, 4 };
+ CHECK_THAT( vector_a, !UnorderedRangeEquals( vector_b ) );
+ }
+ }
+
+ SECTION( "Custom predicate" ) {
+
+ auto close_enough = []( int lhs, int rhs ) {
+ return std::abs( lhs - rhs ) <= 1;
+ };
+
+ SECTION( "Two equal non-empty containers (close enough)" ) {
+ const std::vector<int> vector_a{ { 1, 10, 20 } };
+ const std::vector<int> vector_a_plus_1{ { 11, 21, 2 } };
+ CHECK_THAT( vector_a,
+ UnorderedRangeEquals( vector_a_plus_1, close_enough ) );
+ }
+ SECTION( "Two non-equal non-empty containers (close enough)" ) {
+ const std::vector<int> vector_a{ { 1, 10, 21 } };
+ const std::vector<int> vector_b{ { 11, 21, 3 } };
+ CHECK_THAT( vector_a,
+ !UnorderedRangeEquals( vector_b, close_enough ) );
+ }
+ }
+
+
+ SECTION( "Ranges that need ADL begin/end" ) {
+ unrelated::needs_ADL_begin<int> const
+ needs_adl1{ 1, 2, 3, 4, 5 },
+ needs_adl2{ 1, 2, 3, 4, 5 };
+
+ REQUIRE_THAT( needs_adl1, UnorderedRangeEquals( needs_adl2 ) );
+ }
+}
+
+/**
+ * Return true if the type given has a random access iterator type.
+ */
+template <typename Container>
+static constexpr bool ContainerIsRandomAccess( const Container& ) {
+ using array_iter_category = typename std::iterator_traits<
+ typename Container::iterator>::iterator_category;
+
+ return std::is_base_of<std::random_access_iterator_tag,
+ array_iter_category>::value;
+}
+
+TEST_CASE( "Type conversions of RangeEquals and similar",
+ "[matchers][templated][quantifiers]" ) {
+ using Catch::Matchers::RangeEquals;
+ using Catch::Matchers::UnorderedRangeEquals;
+
+ // In these test, we can always test RangeEquals and
+ // UnorderedRangeEquals in the same way, since we're mostly
+ // testing the template type deductions (and RangeEquals
+ // implies UnorderedRangeEquals)
+
+ SECTION( "Container conversions" ) {
+ SECTION( "Two equal containers of different container types" ) {
+ const std::array<int, 3> array_int_a{ { 1, 2, 3 } };
+ const int c_array[3] = { 1, 2, 3 };
+ CHECK_THAT( array_int_a, RangeEquals( c_array ) );
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( c_array ) );
+ }
+ SECTION( "Two equal containers of different container types "
+ "(differ in array N)" ) {
+ const std::array<int, 3> array_int_3{ { 1, 2, 3 } };
+ const std::array<int, 4> array_int_4{ { 1, 2, 3, 4 } };
+ CHECK_THAT( array_int_3, !RangeEquals( array_int_4 ) );
+ CHECK_THAT( array_int_3, !UnorderedRangeEquals( array_int_4 ) );
+ }
+ SECTION( "Two equal containers of different container types and value "
+ "types" ) {
+ const std::array<int, 3> array_int_a{ { 1, 2, 3 } };
+ const std::vector<int> vector_char_a{ 1, 2, 3 };
+ CHECK_THAT( array_int_a, RangeEquals( vector_char_a ) );
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( vector_char_a ) );
+ }
+ SECTION( "Two equal containers, one random access, one not" ) {
+ const std::array<int, 3> array_int_a{ { 1, 2, 3 } };
+ const std::list<int> list_char_a{ 1, 2, 3 };
+
+ // Verify these types really are different in random access nature
+ STATIC_REQUIRE( ContainerIsRandomAccess( array_int_a ) !=
+ ContainerIsRandomAccess( list_char_a ) );
+
+ CHECK_THAT( array_int_a, RangeEquals( list_char_a ) );
+ CHECK_THAT( array_int_a, UnorderedRangeEquals( list_char_a ) );
+ }
+ }
+
+ SECTION( "Value type" ) {
+ SECTION( "Two equal containers of different value types" ) {
+ const std::vector<int> vector_int_a{ 1, 2, 3 };
+ const std::vector<char> vector_char_a{ 1, 2, 3 };
+ CHECK_THAT( vector_int_a, RangeEquals( vector_char_a ) );
+ CHECK_THAT( vector_int_a, UnorderedRangeEquals( vector_char_a ) );
+ }
+ SECTION( "Two non-equal containers of different value types" ) {
+ const std::vector<int> vector_int_a{ 1, 2, 3 };
+ const std::vector<char> vector_char_b{ 1, 2, 2 };
+ CHECK_THAT( vector_int_a, !RangeEquals( vector_char_b ) );
+ CHECK_THAT( vector_int_a, !UnorderedRangeEquals( vector_char_b ) );
+ }
+ }
+
+ SECTION( "Ranges with begin that needs ADL" ) {
+ unrelated::needs_ADL_begin<int> a{ 1, 2, 3 }, b{ 3, 2, 1 };
+ REQUIRE_THAT( a, !RangeEquals( b ) );
+ REQUIRE_THAT( a, UnorderedRangeEquals( b ) );
+ }
+
+ SECTION( "Custom predicate" ) {
+
+ auto close_enough = []( int lhs, int rhs ) {
+ return std::abs( lhs - rhs ) <= 1;
+ };
+
+ SECTION( "Two equal non-empty containers (close enough)" ) {
+ const std::vector<int> vector_a{ { 1, 2, 3 } };
+ const std::array<char, 3> array_a_plus_1{ { 2, 3, 4 } };
+ CHECK_THAT( vector_a,
+ RangeEquals( array_a_plus_1, close_enough ) );
+ CHECK_THAT( vector_a,
+ UnorderedRangeEquals( array_a_plus_1, close_enough ) );
+ }
+ }
+}
\ No newline at end of file
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Message.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Message.tests.cpp
index 2ec71b4965e82684cc6298d59764e41ea8f53a02..a5e695825797877b42da1badb0e259fd267715ce 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Message.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Message.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Misc.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Misc.tests.cpp
index 93b5ff1ec5ca0606f8569f4acf954556b8fdb16a..6c1fd68f44ad728f1a861747ade1346274031fea 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Misc.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Misc.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Skip.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Skip.tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..661795e119e898d6a1ff10a5b7f6e1b7f4b3ed94
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Skip.tests.cpp
@@ -0,0 +1,100 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators_range.hpp>
+
+#include <iostream>
+
+TEST_CASE( "tests can be skipped dynamically at runtime", "[skipping]" ) {
+ SKIP();
+ FAIL( "this is not reached" );
+}
+
+TEST_CASE( "skipped tests can optionally provide a reason", "[skipping]" ) {
+ const int answer = 43;
+ SKIP( "skipping because answer = " << answer );
+ FAIL( "this is not reached" );
+}
+
+TEST_CASE( "sections can be skipped dynamically at runtime", "[skipping]" ) {
+ SECTION( "not skipped" ) { SUCCEED(); }
+ SECTION( "skipped" ) { SKIP(); }
+ SECTION( "also not skipped" ) { SUCCEED(); }
+}
+
+TEST_CASE( "nested sections can be skipped dynamically at runtime",
+ "[skipping]" ) {
+ SECTION( "A" ) { std::cout << "a"; }
+ SECTION( "B" ) {
+ SECTION( "B1" ) { std::cout << "b1"; }
+ SECTION( "B2" ) { SKIP(); }
+ }
+ std::cout << "!\n";
+}
+
+TEST_CASE( "dynamic skipping works with generators", "[skipping]" ) {
+ const int answer = GENERATE( 41, 42, 43 );
+ if ( answer != 42 ) { SKIP( "skipping because answer = " << answer ); }
+ SUCCEED();
+}
+
+TEST_CASE( "failed assertions before SKIP cause test case to fail",
+ "[skipping][!shouldfail]" ) {
+ CHECK( 3 == 4 );
+ SKIP();
+}
+
+TEST_CASE( "a succeeding test can still be skipped",
+ "[skipping][!shouldfail]" ) {
+ SUCCEED();
+ SKIP();
+}
+
+TEST_CASE( "failing in some unskipped sections causes entire test case to fail",
+ "[skipping][!shouldfail]" ) {
+ SECTION( "skipped" ) { SKIP(); }
+ SECTION( "not skipped" ) { FAIL(); }
+}
+
+TEST_CASE( "failing for some generator values causes entire test case to fail",
+ "[skipping][!shouldfail]" ) {
+ int i = GENERATE( 1, 2, 3, 4 );
+ if ( i % 2 == 0 ) {
+ SKIP();
+ } else {
+ FAIL();
+ }
+}
+
+namespace {
+ class test_skip_generator : public Catch::Generators::IGenerator<int> {
+ public:
+ explicit test_skip_generator() { SKIP( "This generator is empty" ); }
+
+ auto get() const -> int const& override {
+ static constexpr int value = 1;
+ return value;
+ }
+
+ auto next() -> bool override { return false; }
+ };
+
+ static auto make_test_skip_generator()
+ -> Catch::Generators::GeneratorWrapper<int> {
+ return { new test_skip_generator() };
+ }
+
+} // namespace
+
+TEST_CASE( "Empty generators can SKIP in constructor", "[skipping]" ) {
+ // The generator signals emptiness with `SKIP`
+ auto sample = GENERATE( make_test_skip_generator() );
+ // This assertion would fail, but shouldn't trigger
+ REQUIRE( sample == 0 );
+}
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringByte.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringByte.tests.cpp
index e5e12468daf74c550f7853ebe33a5465832f170c..624abbf1ee1dd6e445ad6d6cf2306e36037566b8 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringByte.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringByte.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringChrono.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringChrono.tests.cpp
index 22c31c6870100dfc26a1f961c6d6f07c4e965628..744b899be5f9a37c5d8ff1288714e7315293e9fb 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringChrono.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringChrono.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringGeneral.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringGeneral.tests.cpp
index b8f383b159dadb21fc7b7a4bf61e8022de938cb6..28d60196cb7644dec95f4641710183169b4c2efb 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringGeneral.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringGeneral.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringOptional.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringOptional.tests.cpp
index bc2d2561cc64a0dff71643379ad51665fa8da274..9fd9d6b45300a41444962568a571df7f670aa1ae 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringOptional.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringOptional.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringPair.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringPair.tests.cpp
index 4bf592a4ca286b598224f8c04aa9b72cf1c1431c..f5cb239c9684a1d503e2f0693bba98e5a6db2eb6 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringPair.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringPair.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringTuple.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringTuple.tests.cpp
index 415cbf8384f90cfbdcbb9b5e1164da4515d0c06c..b2813a81789933cf3d06b359eb6a80cc7a1d5113 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringTuple.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringTuple.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringVariant.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringVariant.tests.cpp
index e67a7a2cf063449d972b407eca50a2b4a484d9d7..197ba557a9f1e309ad14fc0dcca55353f832f886 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringVariant.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringVariant.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringVector.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringVector.tests.cpp
index a5ccbfa70af8e96518cdbf07d5eae83f3470775a..c04274485a2ad59d8914c5ce508c07ab14c35ecc 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringVector.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringVector.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/ToStringWhich.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/ToStringWhich.tests.cpp
index 7069734f458cb081b3710bebc055c91efa413f6a..ec7a49ea97fa8e30b03f550528f2211857fb26b5 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/ToStringWhich.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/ToStringWhich.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/Tricky.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/Tricky.tests.cpp
index bcfa7e699d8deda0f298486031e72592da905717..25770340a02de6378d69fc95716a7d0275e59701 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/Tricky.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/Tricky.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/UsageTests/VariadicMacros.tests.cpp b/packages/Catch2/tests/SelfTest/UsageTests/VariadicMacros.tests.cpp
index 7bc3920ecc3cee0c31bdfd42b10e630bb8724008..92048a0651f7281cb550d08bccae885009fbe6d5 100644
--- a/packages/Catch2/tests/SelfTest/UsageTests/VariadicMacros.tests.cpp
+++ b/packages/Catch2/tests/SelfTest/UsageTests/VariadicMacros.tests.cpp
@@ -1,7 +1,7 @@
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/SelfTest/helpers/parse_test_spec.cpp b/packages/Catch2/tests/SelfTest/helpers/parse_test_spec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa64404aeb50f060405e07b52126d77691692faa
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/helpers/parse_test_spec.cpp
@@ -0,0 +1,22 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#include <helpers/parse_test_spec.hpp>
+
+#include <catch2/internal/catch_test_spec_parser.hpp>
+#include <catch2/interfaces/catch_interfaces_tag_alias_registry.hpp>
+
+namespace Catch {
+
+ TestSpec parseTestSpec( std::string const& arg ) {
+ return TestSpecParser( ITagAliasRegistry::get() )
+ .parse( arg )
+ .testSpec();
+ }
+
+} // namespace Catch
diff --git a/packages/Catch2/tests/SelfTest/helpers/parse_test_spec.hpp b/packages/Catch2/tests/SelfTest/helpers/parse_test_spec.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..39ee0713e1856ff5a9faab0be1ca266990a4c22e
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/helpers/parse_test_spec.hpp
@@ -0,0 +1,20 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#ifndef CATCH_TEST_HELPERS_PARSE_TEST_SPEC_HPP_INCLUDED
+#define CATCH_TEST_HELPERS_PARSE_TEST_SPEC_HPP_INCLUDED
+
+#include <catch2/catch_test_spec.hpp>
+
+#include <string>
+
+namespace Catch {
+ TestSpec parseTestSpec( std::string const& arg );
+}
+
+#endif // CATCH_TEST_HELPERS_PARSE_TEST_SPEC_HPP_INCLUDED
diff --git a/packages/Catch2/tests/SelfTest/helpers/range_test_helpers.hpp b/packages/Catch2/tests/SelfTest/helpers/range_test_helpers.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..22c2c3cddf2f6069b6dd0d358eabfdd250dceadd
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/helpers/range_test_helpers.hpp
@@ -0,0 +1,210 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#ifndef CATCH_TEST_HELPERS_RANGE_TEST_HELPERS_HPP_INCLUDED
+#define CATCH_TEST_HELPERS_RANGE_TEST_HELPERS_HPP_INCLUDED
+
+#include <catch2/catch_tostring.hpp>
+
+#include <initializer_list>
+#include <list>
+#include <memory>
+#include <vector>
+
+namespace unrelated {
+ template <typename T>
+ class needs_ADL_begin {
+ std::vector<T> m_elements;
+
+ public:
+ using iterator = typename std::vector<T>::iterator;
+ using const_iterator = typename std::vector<T>::const_iterator;
+
+ needs_ADL_begin( std::initializer_list<T> init ): m_elements( init ) {}
+
+ const_iterator Begin() const { return m_elements.begin(); }
+ const_iterator End() const { return m_elements.end(); }
+
+ friend const_iterator begin( needs_ADL_begin const& lhs ) {
+ return lhs.Begin();
+ }
+ friend const_iterator end( needs_ADL_begin const& rhs ) {
+ return rhs.End();
+ }
+ };
+
+ struct ADL_empty {
+ bool Empty() const { return true; }
+
+ friend bool empty( ADL_empty e ) { return e.Empty(); }
+ };
+
+ struct ADL_size {
+ size_t sz() const { return 12; }
+ friend size_t size( ADL_size s ) { return s.sz(); }
+ };
+
+} // namespace unrelated
+
+#if defined( __clang__ )
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+template <typename T>
+class has_different_begin_end_types {
+ // Using std::vector<T> leads to annoying issues when T is bool
+ // so we just use list because the perf is not critical and ugh.
+ std::list<T> m_elements;
+
+ // Different type for the "end" iterator
+ struct iterator_end {};
+ // Fake-ish forward iterator that only compares to a different type
+ class iterator {
+ using underlying_iter = typename std::list<T>::const_iterator;
+ underlying_iter m_start;
+ underlying_iter m_end;
+
+ public:
+ iterator( underlying_iter start, underlying_iter end ):
+ m_start( start ), m_end( end ) {}
+
+ using iterator_category = std::forward_iterator_tag;
+ using difference_type = std::ptrdiff_t;
+ using value_type = T;
+ using const_reference = T const&;
+ using pointer = T const*;
+
+ friend bool operator==( iterator iter, iterator_end ) {
+ return iter.m_start == iter.m_end;
+ }
+ friend bool operator==(iterator lhs, iterator rhs) {
+ return lhs.m_start == rhs.m_start && lhs.m_end == rhs.m_end;
+ }
+ friend bool operator!=( iterator iter, iterator_end ) {
+ return iter.m_start != iter.m_end;
+ }
+ friend bool operator!=( iterator lhs, iterator rhs ) {
+ return !( lhs == rhs );
+ }
+ iterator& operator++() {
+ ++m_start;
+ return *this;
+ }
+ iterator operator++( int ) {
+ auto tmp( *this );
+ ++m_start;
+ return tmp;
+ }
+ const_reference operator*() const { return *m_start; }
+ pointer operator->() const { return m_start; }
+ };
+
+public:
+ explicit has_different_begin_end_types( std::initializer_list<T> init ):
+ m_elements( init ) {}
+
+ iterator begin() const { return { m_elements.begin(), m_elements.end() }; }
+
+ iterator_end end() const { return {}; }
+};
+
+#if defined( __clang__ )
+# pragma clang diagnostic pop
+#endif
+
+template <typename T>
+struct with_mocked_iterator_access {
+ std::vector<T> m_elements;
+
+ // use plain arrays to have nicer printouts with CHECK(...)
+ mutable std::unique_ptr<bool[]> m_derefed;
+
+ // We want to check which elements were dereferenced when iterating, so
+ // we can check whether iterator-using code traverses range correctly
+ template <bool is_const>
+ class basic_iterator {
+ template <typename U>
+ using constify_t = std::conditional_t<is_const, std::add_const_t<U>, U>;
+
+ constify_t<with_mocked_iterator_access>* m_origin;
+ size_t m_origin_idx;
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using difference_type = std::ptrdiff_t;
+ using value_type = constify_t<T>;
+ using const_reference = typename std::vector<T>::const_reference;
+ using reference = typename std::vector<T>::reference;
+ using pointer = typename std::vector<T>::pointer;
+
+ basic_iterator( constify_t<with_mocked_iterator_access>* origin,
+ std::size_t origin_idx ):
+ m_origin{ origin }, m_origin_idx{ origin_idx } {}
+
+ friend bool operator==( basic_iterator lhs, basic_iterator rhs ) {
+ return lhs.m_origin == rhs.m_origin &&
+ lhs.m_origin_idx == rhs.m_origin_idx;
+ }
+ friend bool operator!=( basic_iterator lhs, basic_iterator rhs ) {
+ return !( lhs == rhs );
+ }
+ basic_iterator& operator++() {
+ ++m_origin_idx;
+ return *this;
+ }
+ basic_iterator operator++( int ) {
+ auto tmp( *this );
+ ++( *this );
+ return tmp;
+ }
+ const_reference operator*() const {
+ assert( m_origin_idx < m_origin->m_elements.size() &&
+ "Attempted to deref invalid position" );
+ m_origin->m_derefed[m_origin_idx] = true;
+ return m_origin->m_elements[m_origin_idx];
+ }
+ pointer operator->() const {
+ assert( m_origin_idx < m_origin->m_elements.size() &&
+ "Attempted to deref invalid position" );
+ return &m_origin->m_elements[m_origin_idx];
+ }
+ };
+
+ using iterator = basic_iterator<false>;
+ using const_iterator = basic_iterator<true>;
+
+ with_mocked_iterator_access( std::initializer_list<T> init ):
+ m_elements( init ),
+ m_derefed( std::make_unique<bool[]>( m_elements.size() ) ) {}
+
+ const_iterator begin() const { return { this, 0 }; }
+ const_iterator end() const { return { this, m_elements.size() }; }
+ iterator begin() { return { this, 0 }; }
+ iterator end() { return { this, m_elements.size() }; }
+};
+
+
+namespace Catch {
+ // make sure with_mocked_iterator_access is not considered a range by Catch,
+ // so that below StringMaker is used instead of the default one for ranges
+ template <typename T>
+ struct is_range<with_mocked_iterator_access<T>> : std::false_type {};
+
+ template <typename T>
+ struct StringMaker<with_mocked_iterator_access<T>> {
+ static std::string
+ convert( with_mocked_iterator_access<T> const& access ) {
+ // We have to avoid the type's iterators, because we check
+ // their use in tests
+ return ::Catch::Detail::stringify( access.m_elements );
+ }
+ };
+} // namespace Catch
+
+#endif // CATCH_TEST_HELPERS_RANGE_TEST_HELPERS_HPP_INCLUDED
diff --git a/packages/Catch2/tests/SelfTest/helpers/type_with_lit_0_comparisons.hpp b/packages/Catch2/tests/SelfTest/helpers/type_with_lit_0_comparisons.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..202c3af4d9a0f8b78bb538290d5f0718260cef0a
--- /dev/null
+++ b/packages/Catch2/tests/SelfTest/helpers/type_with_lit_0_comparisons.hpp
@@ -0,0 +1,44 @@
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#ifndef CATCH_TEST_HELPERS_TYPE_WITH_LIT_0_COMPARISONS_HPP_INCLUDED
+#define CATCH_TEST_HELPERS_TYPE_WITH_LIT_0_COMPARISONS_HPP_INCLUDED
+
+#include <type_traits>
+
+// Should only be constructible from literal 0.
+// Used by `TypeWithLit0Comparisons` for testing comparison
+// ops that only work with literal zero, the way std::*orderings do
+struct ZeroLiteralDetector {
+ constexpr ZeroLiteralDetector( ZeroLiteralDetector* ) noexcept {}
+
+ template <typename T,
+ typename = std::enable_if_t<!std::is_same<T, int>::value>>
+ constexpr ZeroLiteralDetector( T ) = delete;
+};
+
+struct TypeWithLit0Comparisons {
+#define DEFINE_COMP_OP( op ) \
+ friend bool operator op( TypeWithLit0Comparisons, ZeroLiteralDetector ) { \
+ return true; \
+ } \
+ friend bool operator op( ZeroLiteralDetector, TypeWithLit0Comparisons ) { \
+ return false; \
+ }
+
+ DEFINE_COMP_OP( < )
+ DEFINE_COMP_OP( <= )
+ DEFINE_COMP_OP( > )
+ DEFINE_COMP_OP( >= )
+ DEFINE_COMP_OP( == )
+ DEFINE_COMP_OP( != )
+
+#undef DEFINE_COMP_OP
+};
+
+#endif // CATCH_TEST_HELPERS_TYPE_WITH_LIT_0_COMPARISONS_HPP_INCLUDED
diff --git a/packages/Catch2/tests/TestScripts/ConfigureTestsCommon.py b/packages/Catch2/tests/TestScripts/ConfigureTestsCommon.py
index ad5b358be0358d8b4b43a2accd252a4286e71b34..13b1d927ff6fa58779484bb2996e0a0816fef7d6 100644
--- a/packages/Catch2/tests/TestScripts/ConfigureTestsCommon.py
+++ b/packages/Catch2/tests/TestScripts/ConfigureTestsCommon.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/TestScripts/testBazelReporter.py b/packages/Catch2/tests/TestScripts/testBazelReporter.py
index 71014ee26eef59e49d86f8906b776f599e3d4c5d..d0893f81604da46704a8109dea93c3bc9bfa0f1d 100644
--- a/packages/Catch2/tests/TestScripts/testBazelReporter.py
+++ b/packages/Catch2/tests/TestScripts/testBazelReporter.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
@@ -57,10 +57,10 @@ except subprocess.SubprocessError as ex:
test_passing = False
stdout = ex.stdout
else:
- print('Could not run "{}"'.format(args))
+ print('Could not run "{}"'.format(bin_path))
print("Return code: {}".format(ex.returncode))
print("stdout: {}".format(ex.stdout))
- print("stderr: {}".format(ex.stdout))
+ print("stderr: {}".format(ex.stderr))
raise
# Check for valid XML output
diff --git a/packages/Catch2/tests/TestScripts/testBazelSharding.py b/packages/Catch2/tests/TestScripts/testBazelSharding.py
new file mode 100755
index 0000000000000000000000000000000000000000..d4a9aeee89463e252cd90956afe70ef6a6c1b4a1
--- /dev/null
+++ b/packages/Catch2/tests/TestScripts/testBazelSharding.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+
+# Copyright Catch2 Authors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at
+# https://www.boost.org/LICENSE_1_0.txt)
+
+# SPDX-License-Identifier: BSL-1.0
+
+import os
+import re
+import sys
+import subprocess
+
+"""
+Test that Catch2 recognizes the three sharding-related environment variables
+and responds accordingly (running only the selected shard, creating the
+response file, etc).
+
+Requires 2 arguments, path to Catch2 binary to run and the output directory
+for the output file.
+"""
+if len(sys.argv) != 3:
+ print("Wrong number of arguments: {}".format(len(sys.argv)))
+ print("Usage: {} test-bin-path output-dir".format(sys.argv[0]))
+ exit(1)
+
+
+bin_path = os.path.abspath(sys.argv[1])
+output_dir = os.path.abspath(sys.argv[2])
+info_file_path = os.path.join(output_dir, '{}.shard-support'.format(os.path.basename(bin_path)))
+
+# Ensure no file exists from previous test runs
+if os.path.isfile(info_file_path):
+ os.remove(info_file_path)
+
+print('bin path:', bin_path)
+print('shard confirmation path:', info_file_path)
+
+env = os.environ.copy()
+# We will run only one shard, and it should have the passing test.
+# This simplifies our work a bit, and if we have any regression in this
+# functionality we can make more complex tests later.
+env["BAZEL_TEST"] = "1"
+env["TEST_SHARD_INDEX"] = "0"
+env["TEST_TOTAL_SHARDS"] = "2"
+env["TEST_SHARD_STATUS_FILE"] = info_file_path
+
+
+try:
+ ret = subprocess.run(
+ bin_path,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ check=True,
+ universal_newlines=True,
+ env=env
+ )
+ stdout = ret.stdout
+except subprocess.SubprocessError as ex:
+ print('Could not run "{}"'.format(bin_path))
+ print("Return code: {}".format(ex.returncode))
+ print("stdout: {}".format(ex.stdout))
+ print("stderr: {}".format(ex.stderr))
+ raise
+
+
+if not "All tests passed (1 assertion in 1 test case)" in stdout:
+ print("Did not find expected output in stdout.")
+ print("stdout:\n{}".format(stdout))
+ exit(1)
+
+if not os.path.isfile(info_file_path):
+ print("Catch2 did not create expected file at path '{}'".format(info_file_path))
+ exit(2)
diff --git a/packages/Catch2/tests/TestScripts/testConfigureDefaultReporter.py b/packages/Catch2/tests/TestScripts/testConfigureDefaultReporter.py
index 66c88da02eeecb745030d79052f8aff8924c2d9e..5bf9787122e700f2a6ccb1a838d45ea11a068414 100644
--- a/packages/Catch2/tests/TestScripts/testConfigureDefaultReporter.py
+++ b/packages/Catch2/tests/TestScripts/testConfigureDefaultReporter.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
@@ -30,15 +30,12 @@ build_dir_path = os.path.join(os.path.abspath(sys.argv[2]), 'CMakeConfigTests',
configure_and_build(catch2_source_path,
build_dir_path,
- [("CATCH_CONFIG_DEFAULT_REPORTER", "compact")])
+ [("CATCH_CONFIG_DEFAULT_REPORTER", "xml")])
stdout, _ = run_and_return_output(os.path.join(build_dir_path, 'tests'), 'SelfTest', ['[approx][custom]'])
-
-# This matches the summary line made by compact reporter, console reporter's
-# summary line does not match the regex.
-summary_regex = 'Passed \d+ test case with \d+ assertions.'
-if not re.search(summary_regex, stdout):
- print("Could not find '{}' in the stdout".format(summary_regex))
+xml_tag = '</Catch2TestRun>'
+if xml_tag not in stdout:
+ print("Could not find '{}' in the stdout".format(xml_tag))
print('stdout: "{}"'.format(stdout))
exit(2)
diff --git a/packages/Catch2/tests/TestScripts/testConfigureDisable.py b/packages/Catch2/tests/TestScripts/testConfigureDisable.py
index 92946d8d839cf10a23473640c52b39d653738fdd..b0247700c01b6d4e371f2c67077108a2e5b570fc 100644
--- a/packages/Catch2/tests/TestScripts/testConfigureDisable.py
+++ b/packages/Catch2/tests/TestScripts/testConfigureDisable.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/TestScripts/testConfigureDisableStringification.py b/packages/Catch2/tests/TestScripts/testConfigureDisableStringification.py
index a8a53e4f55cdafe50ca728e66256144caa64e96b..33f7853e552409f53845f31be9b44f77cc49d5b5 100644
--- a/packages/Catch2/tests/TestScripts/testConfigureDisableStringification.py
+++ b/packages/Catch2/tests/TestScripts/testConfigureDisableStringification.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/TestScripts/testConfigureExperimentalRedirect.py b/packages/Catch2/tests/TestScripts/testConfigureExperimentalRedirect.py
index b5313fe92b8531840385ec85a700e6b0e7a6746e..09ff51e2de18c4bf6f2a4a417634f22f749ebaa8 100644
--- a/packages/Catch2/tests/TestScripts/testConfigureExperimentalRedirect.py
+++ b/packages/Catch2/tests/TestScripts/testConfigureExperimentalRedirect.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/TestScripts/testPartialTestCaseEvent.py b/packages/Catch2/tests/TestScripts/testPartialTestCaseEvent.py
index 8259d211c67b749a0d82f33f9bc7b5dd93f968c2..55c6e299d2133a5b12eb4c9be3b7afc287c07350 100755
--- a/packages/Catch2/tests/TestScripts/testPartialTestCaseEvent.py
+++ b/packages/Catch2/tests/TestScripts/testPartialTestCaseEvent.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/TestScripts/testRandomOrder.py b/packages/Catch2/tests/TestScripts/testRandomOrder.py
index afab231de37297d5bf0eead007cc0a32466f9ae3..2368423e1ee364b3ea838f902082922e0a6ffc5e 100755
--- a/packages/Catch2/tests/TestScripts/testRandomOrder.py
+++ b/packages/Catch2/tests/TestScripts/testRandomOrder.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/TestScripts/testSharding.py b/packages/Catch2/tests/TestScripts/testSharding.py
index 6902f83c4a4a0be9354acdd90e7a933d2c5d9219..fa6f94d323f0e72afd3d5ab154e24aa89d5bc84f 100755
--- a/packages/Catch2/tests/TestScripts/testSharding.py
+++ b/packages/Catch2/tests/TestScripts/testSharding.py
@@ -2,7 +2,7 @@
# Copyright Catch2 Authors
# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
+# (See accompanying file LICENSE.txt or copy at
# https://www.boost.org/LICENSE_1_0.txt)
# SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tests/meson.build b/packages/Catch2/tests/meson.build
new file mode 100644
index 0000000000000000000000000000000000000000..f525f0412a2f66a78fc4983ec7b5618add36d974
--- /dev/null
+++ b/packages/Catch2/tests/meson.build
@@ -0,0 +1,76 @@
+# Copyright Catch2 Authors
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at
+# https://www.boost.org/LICENSE_1_0.txt)
+
+# SPDX-License-Identifier: BSL-1.0
+
+# define the sources of the self test
+# Please keep these ordered alphabetically
+self_test_sources = files(
+ 'SelfTest/helpers/parse_test_spec.cpp',
+ 'SelfTest/IntrospectiveTests/Algorithms.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Clara.tests.cpp',
+ 'SelfTest/IntrospectiveTests/CmdLine.tests.cpp',
+ 'SelfTest/IntrospectiveTests/CmdLineHelpers.tests.cpp',
+ 'SelfTest/IntrospectiveTests/ColourImpl.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Details.tests.cpp',
+ 'SelfTest/IntrospectiveTests/FloatingPoint.tests.cpp',
+ 'SelfTest/IntrospectiveTests/GeneratorsImpl.tests.cpp',
+ 'SelfTest/IntrospectiveTests/InternalBenchmark.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Parse.tests.cpp',
+ 'SelfTest/IntrospectiveTests/PartTracker.tests.cpp',
+ 'SelfTest/IntrospectiveTests/RandomNumberGeneration.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Reporters.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Sharding.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Stream.tests.cpp',
+ 'SelfTest/IntrospectiveTests/String.tests.cpp',
+ 'SelfTest/IntrospectiveTests/StringManip.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Tag.tests.cpp',
+ 'SelfTest/IntrospectiveTests/TestCaseInfoHasher.tests.cpp',
+ 'SelfTest/IntrospectiveTests/TestSpec.tests.cpp',
+ 'SelfTest/IntrospectiveTests/TestSpecParser.tests.cpp',
+ 'SelfTest/IntrospectiveTests/TextFlow.tests.cpp',
+ 'SelfTest/IntrospectiveTests/ToString.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Traits.tests.cpp',
+ 'SelfTest/IntrospectiveTests/UniquePtr.tests.cpp',
+ 'SelfTest/IntrospectiveTests/Xml.tests.cpp',
+ 'SelfTest/TestRegistrations.cpp',
+ 'SelfTest/TimingTests/Sleep.tests.cpp',
+ 'SelfTest/UsageTests/Approx.tests.cpp',
+ 'SelfTest/UsageTests/BDD.tests.cpp',
+ 'SelfTest/UsageTests/Benchmark.tests.cpp',
+ 'SelfTest/UsageTests/Class.tests.cpp',
+ 'SelfTest/UsageTests/Compilation.tests.cpp',
+ 'SelfTest/UsageTests/Condition.tests.cpp',
+ 'SelfTest/UsageTests/Decomposition.tests.cpp',
+ 'SelfTest/UsageTests/EnumToString.tests.cpp',
+ 'SelfTest/UsageTests/Exception.tests.cpp',
+ 'SelfTest/UsageTests/Generators.tests.cpp',
+ 'SelfTest/UsageTests/Matchers.tests.cpp',
+ 'SelfTest/UsageTests/MatchersRanges.tests.cpp',
+ 'SelfTest/UsageTests/Message.tests.cpp',
+ 'SelfTest/UsageTests/Misc.tests.cpp',
+ 'SelfTest/UsageTests/ToStringByte.tests.cpp',
+ 'SelfTest/UsageTests/ToStringChrono.tests.cpp',
+ 'SelfTest/UsageTests/ToStringGeneral.tests.cpp',
+ 'SelfTest/UsageTests/ToStringOptional.tests.cpp',
+ 'SelfTest/UsageTests/ToStringPair.tests.cpp',
+ 'SelfTest/UsageTests/ToStringTuple.tests.cpp',
+ 'SelfTest/UsageTests/ToStringVariant.tests.cpp',
+ 'SelfTest/UsageTests/ToStringVector.tests.cpp',
+ 'SelfTest/UsageTests/ToStringWhich.tests.cpp',
+ 'SelfTest/UsageTests/Tricky.tests.cpp',
+ 'SelfTest/UsageTests/VariadicMacros.tests.cpp',
+)
+
+# This isn't as good as the CMake tests, but it proves that we've
+# actually put something in the library files.
+self_test = executable(
+ 'SelfTest',
+ self_test_sources,
+ include_directories: ['../src', './SelfTest'],
+ link_with: [catch2_with_main, catch2],
+)
+
+test('SelfTest', self_test)
diff --git a/packages/Catch2/tools/misc/appveyorMergeCoverageScript.py b/packages/Catch2/tools/misc/appveyorMergeCoverageScript.py
index 7cf408d24ec2b9ebd2bd61258d28d523c3392da9..5b71f6e1291e9e64af1e060145b5d7b61f29eec7 100644
--- a/packages/Catch2/tools/misc/appveyorMergeCoverageScript.py
+++ b/packages/Catch2/tools/misc/appveyorMergeCoverageScript.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python2
+#!/usr/bin/env python3
import glob
import subprocess
diff --git a/packages/Catch2/tools/scripts/approvalTests.py b/packages/Catch2/tools/scripts/approvalTests.py
index 098f40e35bb61f776dab8810dcc03c8a8f2ec8d2..4146b646febc20861148b2bc5de5ed9910cca237 100755
--- a/packages/Catch2/tools/scripts/approvalTests.py
+++ b/packages/Catch2/tools/scripts/approvalTests.py
@@ -1,13 +1,12 @@
#!/usr/bin/env python3
-from __future__ import print_function
-
import io
import os
import sys
import subprocess
import re
import difflib
+import shutil
import scriptCommon
from scriptCommon import catchPath
@@ -17,14 +16,43 @@ if os.name == 'nt':
os.system('')
rootPath = os.path.join(catchPath, 'tests/SelfTest/Baselines')
+# Init so it is guaranteed to fail loudly if the scoping gets messed up
+outputDirPath = None
+
+if len(sys.argv) == 3:
+ cmdPath = sys.argv[1]
+ outputDirBasePath = sys.argv[2]
+ outputDirPath = os.path.join(outputDirBasePath, 'ApprovalTests')
+ if not os.path.isdir(outputDirPath):
+ os.mkdir(outputDirPath)
+else:
+ print('Usage: {} path-to-SelfTest-executable path-to-temp-output-dir'.format(sys.argv[0]))
+ exit(1)
+
+
+
+def get_rawResultsPath(baseName):
+ return os.path.join(outputDirPath, '_{0}.tmp'.format(baseName))
+
+def get_baselinesPath(baseName):
+ return os.path.join(rootPath, '{0}.approved.txt'.format(baseName))
+
+def _get_unapprovedPath(path, baseName):
+ return os.path.join(path, '{0}.unapproved.txt'.format(baseName))
+
+def get_filteredResultsPath(baseName):
+ return _get_unapprovedPath(outputDirPath, baseName)
+
+def get_unapprovedResultsPath(baseName):
+ return _get_unapprovedPath(rootPath, baseName)
langFilenameParser = re.compile(r'(.+\.[ch]pp)')
filelocParser = re.compile(r'''
- .*/
- (.+\.[ch]pp) # filename
- (?::|\() # : is starting separator between filename and line number on Linux, ( on Windows
- ([0-9]*) # line number
- \)? # Windows also has an ending separator, )
+ (?P<path_prefix>tests/SelfTest/(?:\w+/)*) # We separate prefix and fname, so that
+ (?P<filename>\w+\.tests\.[ch]pp) # we can keep only filename
+ (?::|\() # Linux has : as separator between fname and line number, Windows uses (
+ (\d*) # line number
+ \)? # Windows also uses an ending separator, )
''', re.VERBOSE)
lineNumberParser = re.compile(r' line="[0-9]*"')
hexParser = re.compile(r'\b(0[xX][0-9a-fA-F]+)\b')
@@ -50,14 +78,8 @@ sinceEpochParser = re.compile(r'\d+ .+ since epoch')
# The weird OR is there to always have at least empty string for group 1
tapTestNumParser = re.compile(r'^((?:not ok)|(?:ok)|(?:warning)|(?:info)) (\d+) -')
-if len(sys.argv) == 2:
- cmdPath = sys.argv[1]
-else:
- cmdPath = os.path.join(catchPath, scriptCommon.getBuildExecutable())
-
overallResult = 0
-
def diffFiles(fileA, fileB):
with io.open(fileA, 'r', encoding='utf-8', errors='surrogateescape') as file:
aLines = [line.rstrip() for line in file.readlines()]
@@ -97,14 +119,11 @@ def filterLine(line, isCompact):
line = normalizeFilepath(line)
# strip source line numbers
- m = filelocParser.match(line)
- if m:
- # note that this also strips directories, leaving only the filename
- filename, lnum = m.groups()
- lnum = ":<line number>" if lnum else ""
- line = filename + lnum + line[m.end():]
- else:
- line = lineNumberParser.sub(" ", line)
+ # Note that this parser assumes an already normalized filepath from above,
+ # and might break terribly if it is moved around before the normalization.
+ line = filelocParser.sub('\g<filename>:<line number>', line)
+
+ line = lineNumberParser.sub(" ", line)
if isCompact:
line = line.replace(': FAILED', ': failed')
@@ -134,18 +153,6 @@ def filterLine(line, isCompact):
return line
-def get_rawResultsPath(baseName):
- return os.path.join(rootPath, '_{0}.tmp'.format(baseName))
-
-
-def get_baselinesPath(baseName):
- return os.path.join(rootPath, '{0}.approved.txt'.format(baseName))
-
-
-def get_filteredResultsPath(baseName):
- return os.path.join(rootPath, '{0}.unapproved.txt'.format(baseName))
-
-
def run_test(baseName, args):
args[0:0] = [cmdPath]
if not os.path.exists(cmdPath):
@@ -174,21 +181,20 @@ def check_outputs(baseName):
os.remove(rawResultsPath)
print()
print(baseName + ":")
- if os.path.exists(baselinesPath):
- diffResult = diffFiles(baselinesPath, filteredResultsPath)
- if diffResult:
- print('\n'.join(diffResult))
- print(" \n****************************\n \033[91mResults differed")
- if len(diffResult) > overallResult:
- overallResult = len(diffResult)
- else:
- os.remove(filteredResultsPath)
- print(" \033[92mResults matched")
- print("\033[0m")
+ if not os.path.exists(baselinesPath):
+ print( 'first approval')
+ overallResult += 1
+ return
+
+ diffResult = diffFiles(baselinesPath, filteredResultsPath)
+ if diffResult:
+ print('\n'.join(diffResult))
+ print(" \n****************************\n \033[91mResults differed\033[0m")
+ overallResult += 1
+ shutil.move(filteredResultsPath, get_unapprovedResultsPath(baseName))
else:
- print(" first approval")
- if overallResult == 0:
- overallResult = 1
+ os.remove(filteredResultsPath)
+ print(" \033[92mResults matched\033[0m")
def approve(baseName, args):
@@ -205,6 +211,7 @@ base_args = ["--order", "lex", "--rng-seed", "1", "--colour-mode", "none"]
## special cases first:
# Standard console reporter
approve("console.std", ["~[!nonportable]~[!benchmark]~[approvals] *"] + base_args)
+
# console reporter, include passes, warn about No Assertions, limit failures to first 4
approve("console.swa4", ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions", "-x", "4"] + base_args)
@@ -216,8 +223,8 @@ for reporter in reporters:
reporter_args = ['-r', reporter]
approve(filename, common_args + reporter_args)
-## All reporters at the same time
+## All reporters at the same time
common_args = ["~[!nonportable]~[!benchmark]~[approvals] *", "-s", "-w", "NoAssertions"] + base_args
filenames = ['{}.sw.multi'.format(reporter) for reporter in reporters]
reporter_args = []
@@ -225,6 +232,7 @@ for reporter, filename in zip(reporters, filenames):
reporter_args += ['-r', '{}::out={}'.format(reporter, get_rawResultsPath(filename))]
run_test("default.sw.multi", common_args + reporter_args)
+
check_outputs("default.sw.multi")
for reporter, filename in zip(reporters, filenames):
check_outputs(filename)
@@ -232,4 +240,4 @@ for reporter, filename in zip(reporters, filenames):
if overallResult != 0:
print("If these differences are expected, run approve.py to approve new baselines.")
-exit(overallResult)
+ exit(2)
diff --git a/packages/Catch2/tools/scripts/approve.py b/packages/Catch2/tools/scripts/approve.py
index 997b8c710b4739e11aca30ef812f15461492b01a..6d73be5c8bedb6865c84e1b52ce32b9818f3ea5c 100755
--- a/packages/Catch2/tools/scripts/approve.py
+++ b/packages/Catch2/tools/scripts/approve.py
@@ -1,7 +1,5 @@
#!/usr/bin/env python3
-from __future__ import print_function
-
import os
import sys
import shutil
diff --git a/packages/Catch2/tools/scripts/buildAndTest.cmd b/packages/Catch2/tools/scripts/buildAndTest.cmd
index e5222a01c20445d6941e87507fbc1d0ebbaceb56..7c10e564f0dcfb719fd163d14b2e3a0a90e3aec1 100644
--- a/packages/Catch2/tools/scripts/buildAndTest.cmd
+++ b/packages/Catch2/tools/scripts/buildAndTest.cmd
@@ -6,7 +6,7 @@ rem 1. Regenerate the amalgamated distribution
python tools\scripts\generateAmalgamatedFiles.py
rem 2. Configure the full test build
-cmake -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_ENABLE_CONFIGURE_TESTS=ON
+cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests
rem 3. Run the actual build
cmake --build debug-build
diff --git a/packages/Catch2/tools/scripts/buildAndTest.sh b/packages/Catch2/tools/scripts/buildAndTest.sh
index 4a741598b014a0c78196fc8e6d31957459ae5e1f..01a82837a3927c97241452341172aaa4478bec0b 100755
--- a/packages/Catch2/tools/scripts/buildAndTest.sh
+++ b/packages/Catch2/tools/scripts/buildAndTest.sh
@@ -8,7 +8,7 @@
./tools/scripts/generateAmalgamatedFiles.py
# 2. Configure the full test build
-cmake -Bdebug-build -H. -DCMAKE_BUILD_TYPE=Debug -DCATCH_DEVELOPMENT_BUILD=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_ENABLE_CONFIGURE_TESTS=ON
+cmake -B debug-build -S . -DCMAKE_BUILD_TYPE=Debug --preset all-tests
# 3. Run the actual build
cmake --build debug-build
diff --git a/packages/Catch2/tools/scripts/checkConvenienceHeaders.py b/packages/Catch2/tools/scripts/checkConvenienceHeaders.py
index 054d3bd97840024a76360bb5a9bf055972875296..41b52cedc39d340691a8e89c11d8db5a1539a3d5 100755
--- a/packages/Catch2/tools/scripts/checkConvenienceHeaders.py
+++ b/packages/Catch2/tools/scripts/checkConvenienceHeaders.py
@@ -120,7 +120,8 @@ def verify_convenience_header(folder):
# 4) Are all required headers present?
file_incs_set = set(file_incs)
for include in target_includes:
- if include not in file_incs_set:
+ if (include not in file_incs_set and
+ include != 'catch2/internal/catch_windows_h_proxy.hpp'):
errors_found = True
print("'{}': missing include '{}'".format(header_name, include))
diff --git a/packages/Catch2/tools/scripts/checkLicense.py b/packages/Catch2/tools/scripts/checkLicense.py
index 634b0bfa95fbd16d3f6da7ddc6788aeb744e8491..9a9497692e79e328b42bdebbb1527be4c30495ac 100755
--- a/packages/Catch2/tools/scripts/checkLicense.py
+++ b/packages/Catch2/tools/scripts/checkLicense.py
@@ -7,7 +7,7 @@ correct_licence = """\
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
diff --git a/packages/Catch2/tools/scripts/developBuild.py b/packages/Catch2/tools/scripts/developBuild.py
index 9252c7d63860c3cf2de341c0d029dfaf18d63efe..8837770cadb6f41ceafc61767b37ce211bd331fb 100755
--- a/packages/Catch2/tools/scripts/developBuild.py
+++ b/packages/Catch2/tools/scripts/developBuild.py
@@ -1,10 +1,9 @@
#!/usr/bin/env python3
-from __future__ import print_function
import releaseCommon
v = releaseCommon.Version()
v.incrementBuildNumber()
releaseCommon.performUpdates(v)
-print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
+print( "Updated files to v{0}".format( v.getVersionString() ) )
diff --git a/packages/Catch2/tools/scripts/extractFeaturesFromReleaseNotes.py b/packages/Catch2/tools/scripts/extractFeaturesFromReleaseNotes.py
index 11f4955c0b4be262460e83f0a138684883eb9512..d8be04376d6a0fe1381d3017b8575b15becb6420 100644
--- a/packages/Catch2/tools/scripts/extractFeaturesFromReleaseNotes.py
+++ b/packages/Catch2/tools/scripts/extractFeaturesFromReleaseNotes.py
@@ -21,8 +21,6 @@
# to add the 'Introduced in Catch ...' snippets to the relevant pages.
#
-from __future__ import print_function
-
import re
diff --git a/packages/Catch2/tools/scripts/fixWhitespace.py b/packages/Catch2/tools/scripts/fixWhitespace.py
index 4591c1c444f5352c330cfcc12e34c0db9ccb91d0..5840e79047e16d78dfb65c0bf1c1688457a621f8 100755
--- a/packages/Catch2/tools/scripts/fixWhitespace.py
+++ b/packages/Catch2/tools/scripts/fixWhitespace.py
@@ -1,6 +1,5 @@
#!/usr/bin/env python3
-from __future__ import print_function
import os
from scriptCommon import catchPath
diff --git a/packages/Catch2/tools/scripts/generateAmalgamatedFiles.py b/packages/Catch2/tools/scripts/generateAmalgamatedFiles.py
index 812712a3a7c22bab5275419b720c9de0f85bf7f0..99fc446bf96e8dccbfb927a183fdac1670477e67 100755
--- a/packages/Catch2/tools/scripts/generateAmalgamatedFiles.py
+++ b/packages/Catch2/tools/scripts/generateAmalgamatedFiles.py
@@ -16,7 +16,7 @@ output_cpp = os.path.join(catchPath, 'extras', 'catch_amalgamated.cpp')
copyright_lines = [
'// Copyright Catch2 Authors\n',
'// Distributed under the Boost Software License, Version 1.0.\n',
-'// (See accompanying file LICENSE_1_0.txt or copy at\n',
+'// (See accompanying file LICENSE.txt or copy at\n',
'// https://www.boost.org/LICENSE_1_0.txt)\n',
'// SPDX-License-Identifier: BSL-1.0\n',
]
@@ -26,7 +26,7 @@ copyright_lines = [
file_header = '''\
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
+// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
@@ -108,6 +108,7 @@ def generate_cpp():
with open(output_cpp, mode='w', encoding='utf-8') as cpp:
cpp.write(formatted_file_header(Version()))
cpp.write('\n#include "catch_amalgamated.hpp"\n')
+ concatenate_file(cpp, os.path.join(root_path, 'catch2/internal/catch_windows_h_proxy.hpp'), False)
for file in cpp_files:
concatenate_file(cpp, file, False)
print('Concatenated {} cpp files'.format(len(cpp_files)))
diff --git a/packages/Catch2/tools/scripts/majorRelease.py b/packages/Catch2/tools/scripts/majorRelease.py
index e9e285a898b967d041ee86e78290a843c97819df..eb712b46612ca329e56b26d1bcfbcbf839de98f7 100755
--- a/packages/Catch2/tools/scripts/majorRelease.py
+++ b/packages/Catch2/tools/scripts/majorRelease.py
@@ -1,10 +1,9 @@
#!/usr/bin/env python3
-from __future__ import print_function
import releaseCommon
v = releaseCommon.Version()
v.incrementMajorVersion()
releaseCommon.performUpdates(v)
-print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
+print( "Updated files to v{0}".format( v.getVersionString() ) )
diff --git a/packages/Catch2/tools/scripts/minorRelease.py b/packages/Catch2/tools/scripts/minorRelease.py
index 2b57c2eab59075b62b8cee604dc32e8299a8f559..0992c8fb9867053236bf48246fbc0a127c736666 100755
--- a/packages/Catch2/tools/scripts/minorRelease.py
+++ b/packages/Catch2/tools/scripts/minorRelease.py
@@ -1,10 +1,9 @@
#!/usr/bin/env python3
-from __future__ import print_function
import releaseCommon
v = releaseCommon.Version()
v.incrementMinorVersion()
releaseCommon.performUpdates(v)
-print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
+print( "Updated files to v{0}".format( v.getVersionString() ) )
diff --git a/packages/Catch2/tools/scripts/patchRelease.py b/packages/Catch2/tools/scripts/patchRelease.py
index d20db714c4341875bfed8a8a63e1e726f44668bb..48256c15dfdc87030af08d98b9e7048d6512bd31 100755
--- a/packages/Catch2/tools/scripts/patchRelease.py
+++ b/packages/Catch2/tools/scripts/patchRelease.py
@@ -1,10 +1,9 @@
#!/usr/bin/env python3
-from __future__ import print_function
import releaseCommon
v = releaseCommon.Version()
v.incrementPatchNumber()
releaseCommon.performUpdates(v)
-print( "Updated Version.hpp, README and Conan to v{0}".format( v.getVersionString() ) )
+print( "Updated files to v{0}".format( v.getVersionString() ) )
diff --git a/packages/Catch2/tools/scripts/releaseCommon.py b/packages/Catch2/tools/scripts/releaseCommon.py
index 20ef1b0cd8064d6e95649c4b45babe71dcb970e9..0d995eaf7c9acf4846755339cbe094c93328a052 100644
--- a/packages/Catch2/tools/scripts/releaseCommon.py
+++ b/packages/Catch2/tools/scripts/releaseCommon.py
@@ -1,10 +1,6 @@
-from __future__ import print_function
-
import os
-import sys
import re
import string
-import glob
import fnmatch
from scriptCommon import catchPath
@@ -15,6 +11,7 @@ versionPath = os.path.join( rootPath, "catch_version.cpp" )
definePath = os.path.join(rootPath, 'catch_version_macros.hpp')
readmePath = os.path.join( catchPath, "README.md" )
cmakePath = os.path.join(catchPath, 'CMakeLists.txt')
+mesonPath = os.path.join(catchPath, 'meson.build')
class Version:
def __init__(self):
@@ -89,6 +86,16 @@ def updateCmakeFile(version):
file.write(replacementRegex.sub(replacement, line))
+def updateMesonFile(version):
+ with open(mesonPath, 'rb') as file:
+ lines = file.readlines()
+ replacementRegex = re.compile(b'''version\s*:\s*'(\\d+.\\d+.\\d+)', # CML version placeholder, don't delete''')
+ replacement = '''version: '{0}', # CML version placeholder, don't delete'''.format(version.getVersionString()).encode('ascii')
+ with open(mesonPath, 'wb') as file:
+ for line in lines:
+ file.write(replacementRegex.sub(replacement, line))
+
+
def updateVersionDefine(version):
# First member of the tuple is the compiled regex object, the second is replacement if it matches
replacementRegexes = [(re.compile(b'#define CATCH_VERSION_MAJOR \\d+'),'#define CATCH_VERSION_MAJOR {}'.format(version.majorVersion).encode('ascii')),
@@ -132,4 +139,5 @@ def performUpdates(version):
generateAmalgamatedFiles.generate_cpp()
updateCmakeFile(version)
+ updateMesonFile(version)
updateDocumentationVersionPlaceholders(version)
diff --git a/packages/Catch2/tools/scripts/scriptCommon.py b/packages/Catch2/tools/scripts/scriptCommon.py
index a6930063a9b8bba9cb81526a388abaa4f39986a0..5894185dd24a95d148d092a5e8a279d7e2e548ee 100644
--- a/packages/Catch2/tools/scripts/scriptCommon.py
+++ b/packages/Catch2/tools/scripts/scriptCommon.py
@@ -1,31 +1,4 @@
import os
import sys
-import subprocess
-
catchPath = os.path.dirname(os.path.dirname(os.path.realpath( os.path.dirname(sys.argv[0]))))
-
-def getBuildExecutable():
- if os.name == 'nt':
- dir = os.environ.get('CATCH_DEV_OUT_DIR', "cmake-build-debug/projects/SelfTest.exe")
- return dir
- else:
- dir = os.environ.get('CATCH_DEV_OUT_DIR', "cmake-build-debug/projects/SelfTest")
- return dir
-
-
-def runAndCapture( args ):
- child = subprocess.Popen(" ".join( args ), shell=True, stdout=subprocess.PIPE)
- lines = []
- line = ""
- while True:
- out = child.stdout.read(1)
- if out == '' and child.poll():
- break
- if out != '':
- if out == '\n':
- lines.append( line )
- line = ""
- else:
- line = line + out
- return lines
diff --git a/packages/Catch2/tools/scripts/updateDocumentToC.py b/packages/Catch2/tools/scripts/updateDocumentToC.py
index 41b48752cf68ded013ebabee38d489a229607c3c..1840cecc63bdbf80eb5576785a1b59f87f834952 100755
--- a/packages/Catch2/tools/scripts/updateDocumentToC.py
+++ b/packages/Catch2/tools/scripts/updateDocumentToC.py
@@ -11,8 +11,6 @@
# https://github.com/rasbt/markdown-toclify
#
-from __future__ import print_function
-
import argparse
import glob
import os
@@ -289,7 +287,7 @@ def markdownToclify(
Path to the markdown output file.
min_toc_len: int (default: 2)
- Miniumum number of entries to create a table of contents for.
+ Minimum number of entries to create a table of contents for.
github: bool (default: False)
Uses GitHub TOC syntax if True.