2022-01-29 00:03:43 +01:00
|
|
|
|
|
|
|
// 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
|
2014-05-16 07:50:00 +02:00
|
|
|
|
2021-02-06 20:12:07 +01:00
|
|
|
#include <catch2/catch_config.hpp>
|
2020-03-30 10:34:21 +02:00
|
|
|
#include <catch2/catch_approx.hpp>
|
2020-01-20 23:24:04 +01:00
|
|
|
#include <catch2/catch_test_macros.hpp>
|
2020-03-01 19:59:18 +01:00
|
|
|
#include <catch2/matchers/catch_matchers_string.hpp>
|
2020-03-30 10:34:21 +02:00
|
|
|
#include <catch2/internal/catch_test_spec_parser.hpp>
|
2022-02-17 20:44:27 +01:00
|
|
|
#include <catch2/catch_user_config.hpp>
|
2020-03-30 10:34:21 +02:00
|
|
|
#include <catch2/catch_test_case_info.hpp>
|
|
|
|
#include <catch2/internal/catch_commandline.hpp>
|
|
|
|
#include <catch2/generators/catch_generators.hpp>
|
2022-03-27 23:35:41 +02:00
|
|
|
#include <catch2/internal/catch_compiler_capabilities.hpp>
|
|
|
|
|
2014-05-16 07:50:00 +02:00
|
|
|
|
2019-11-04 21:35:57 +01:00
|
|
|
namespace {
|
|
|
|
auto fakeTestCase(const char* name, const char* desc = "") { return Catch::makeTestCaseInfo("", { name, desc }, CATCH_INTERNAL_LINEINFO); }
|
|
|
|
}
|
2014-05-16 07:50:00 +02:00
|
|
|
|
2019-11-05 23:28:47 +01:00
|
|
|
TEST_CASE( "Parse test names and tags", "[command-line][test-spec]" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
|
|
|
|
using Catch::parseTestSpec;
|
|
|
|
using Catch::TestSpec;
|
|
|
|
|
2019-11-04 21:35:57 +01:00
|
|
|
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" );
|
2014-05-16 07:50:00 +02:00
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Empty test spec should have no filters" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec;
|
|
|
|
CHECK( spec.hasFilters() == false );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Test spec from empty string should have no filters" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "" );
|
|
|
|
CHECK( spec.hasFilters() == false );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Test spec from just a comma should have no filters" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "," );
|
|
|
|
CHECK( spec.hasFilters() == false );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Test spec from name should have one filter" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "b" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Test spec from quoted name should have one filter" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "\"b\"" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Test spec from name should have one filter" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "b" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Wildcard at the start" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "*spaces" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
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 );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Wildcard at the end" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "long*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
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 );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Wildcard at both ends" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "*name*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
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 );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Redundant wildcard at the start" ) {
|
2014-05-19 19:07:53 +02:00
|
|
|
TestSpec spec = parseTestSpec( "*a" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
2014-05-19 19:07:53 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Redundant wildcard at the end" ) {
|
2014-05-19 19:07:53 +02:00
|
|
|
TestSpec spec = parseTestSpec( "a*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
2014-05-19 19:07:53 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Redundant wildcard at both ends" ) {
|
2014-05-19 19:07:53 +02:00
|
|
|
TestSpec spec = parseTestSpec( "*a*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
2014-05-19 19:07:53 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Wildcard at both ends, redundant at start" ) {
|
2014-05-19 19:07:53 +02:00
|
|
|
TestSpec spec = parseTestSpec( "*longer*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
|
|
|
CHECK( spec.matches( *tcD ) == true );
|
2014-05-19 19:07:53 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Just wildcard" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
|
|
|
CHECK( spec.matches( *tcD ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
|
|
|
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Single tag" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "[one]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Single tag, two matches" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "[x]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Two tags" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "[two][x]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Two tags, spare separated" ) {
|
2014-05-20 19:28:19 +02:00
|
|
|
TestSpec spec = parseTestSpec( "[two] [x]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
2014-05-20 19:28:19 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Wildcarded name and tag" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "*name*[x]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
|
|
|
CHECK( spec.matches( *tcD ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "Single tag exclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "~[one]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "One tag exclusion and one tag inclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "~[two][x]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "One tag exclusion and one wldcarded name inclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "~[two]*name*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
|
|
|
CHECK( spec.matches( *tcD ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "One tag exclusion, using exclude:, and one wldcarded name inclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "exclude:[two]*name*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
|
|
|
CHECK( spec.matches( *tcD ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "name exclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "~b" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
|
|
|
CHECK( spec.matches( *tcD ) == true );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "wildcarded name exclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "~*name*" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
|
|
|
CHECK( spec.matches( *tcD ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "wildcarded name exclusion with tag inclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "~*name*,[three]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
|
|
|
CHECK( spec.matches( *tcD ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "wildcarded name exclusion, using exclude:, with tag inclusion" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "exclude:*name*,[three]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == true );
|
|
|
|
CHECK( spec.matches( *tcB ) == true );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
|
|
|
CHECK( spec.matches( *tcD ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "two wildcarded names" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "\"longer*\"\"*spaces\"" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == true );
|
|
|
|
CHECK( spec.matches( *tcD ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "empty tag" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "[]" );
|
|
|
|
CHECK( spec.hasFilters() == false );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
|
|
|
CHECK( spec.matches( *tcD ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "empty quoted name" ) {
|
2014-05-16 07:50:00 +02:00
|
|
|
TestSpec spec = parseTestSpec( "\"\"" );
|
|
|
|
CHECK( spec.hasFilters() == false );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
|
|
|
CHECK( spec.matches( *tcD ) == false );
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-07-13 10:20:37 +02:00
|
|
|
SECTION( "quoted string followed by tag exclusion" ) {
|
2014-05-16 19:24:07 +02:00
|
|
|
TestSpec spec = parseTestSpec( "\"*name*\"~[.]" );
|
|
|
|
CHECK( spec.hasFilters() == true );
|
2019-11-04 21:35:57 +01:00
|
|
|
CHECK( spec.matches( *tcA ) == false );
|
|
|
|
CHECK( spec.matches( *tcB ) == false );
|
|
|
|
CHECK( spec.matches( *tcC ) == false );
|
|
|
|
CHECK( spec.matches( *tcD ) == true );
|
2014-05-16 19:24:07 +02:00
|
|
|
}
|
2019-09-09 11:30:45 +02:00
|
|
|
SECTION( "Leading and trailing spaces in test spec" ) {
|
|
|
|
TestSpec spec = parseTestSpec( "\" aardvark \"" );
|
2019-11-04 21:35:57 +01:00
|
|
|
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" ) ) );
|
2014-05-16 07:50:00 +02:00
|
|
|
|
2019-09-09 11:30:45 +02:00
|
|
|
}
|
|
|
|
SECTION( "Leading and trailing spaces in test name" ) {
|
|
|
|
TestSpec spec = parseTestSpec( "aardvark" );
|
2019-11-04 21:35:57 +01:00
|
|
|
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" ) ) );
|
2019-11-05 23:28:47 +01:00
|
|
|
}
|
|
|
|
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]")));
|
2019-09-09 11:30:45 +02:00
|
|
|
}
|
2014-05-16 07:50:00 +02:00
|
|
|
}
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2020-04-12 18:44:42 +02:00
|
|
|
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)")));
|
|
|
|
}
|
|
|
|
|
2020-04-17 21:16:18 +02:00
|
|
|
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)")));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-13 17:03:27 +01:00
|
|
|
TEST_CASE( "Process can be configured on command line", "[config][command-line]" ) {
|
|
|
|
|
|
|
|
using namespace Catch::Matchers;
|
|
|
|
|
|
|
|
Catch::ConfigData config;
|
|
|
|
auto cli = Catch::makeCommandLineParser(config);
|
|
|
|
|
|
|
|
SECTION("empty args don't cause a crash") {
|
|
|
|
auto result = cli.parse({""});
|
|
|
|
CHECK(result);
|
|
|
|
CHECK(config.processName == "");
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("default - no arguments") {
|
|
|
|
auto result = cli.parse({"test"});
|
|
|
|
CHECK(result);
|
|
|
|
CHECK(config.processName == "test");
|
|
|
|
CHECK(config.shouldDebugBreak == false);
|
|
|
|
CHECK(config.abortAfter == -1);
|
|
|
|
CHECK(config.noThrow == false);
|
2022-02-17 20:44:27 +01:00
|
|
|
CHECK( config.reporterSpecifications.empty() );
|
2018-02-08 23:18:32 +01:00
|
|
|
|
|
|
|
Catch::Config cfg(config);
|
|
|
|
CHECK_FALSE(cfg.hasTestFilters());
|
2022-02-17 20:44:27 +01:00
|
|
|
|
|
|
|
// The Config is responsible for mixing in the default reporter
|
|
|
|
auto expectedReporter =
|
|
|
|
#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
|
|
|
|
CATCH_CONFIG_DEFAULT_REPORTER
|
|
|
|
#else
|
|
|
|
"console"
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
|
2022-04-04 21:07:04 +02:00
|
|
|
CHECK( cfg.getReporterSpecs().size() == 1 );
|
|
|
|
CHECK( cfg.getReporterSpecs()[0] ==
|
2022-04-13 14:55:05 +02:00
|
|
|
Catch::ReporterSpec{ expectedReporter, {}, {}, {} } );
|
|
|
|
CHECK( cfg.getProcessedReporterSpecs().size() == 1 );
|
|
|
|
CHECK( cfg.getProcessedReporterSpecs()[0] ==
|
|
|
|
Catch::ProcessedReporterSpec{ expectedReporter,
|
|
|
|
std::string{},
|
|
|
|
Catch::ColourMode::PlatformDefault,
|
|
|
|
{} } );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("test lists") {
|
2018-06-25 20:04:29 +02:00
|
|
|
SECTION("Specify one test case using") {
|
2017-11-13 17:03:27 +01:00
|
|
|
auto result = cli.parse({"test", "test1"});
|
|
|
|
CHECK(result);
|
|
|
|
|
|
|
|
Catch::Config cfg(config);
|
2018-02-08 23:18:32 +01:00
|
|
|
REQUIRE(cfg.hasTestFilters());
|
2019-11-04 21:35:57 +01:00
|
|
|
REQUIRE(cfg.testSpec().matches(*fakeTestCase("notIncluded")) == false);
|
|
|
|
REQUIRE(cfg.testSpec().matches(*fakeTestCase("test1")));
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
SECTION("Specify one test case exclusion using exclude:") {
|
|
|
|
auto result = cli.parse({"test", "exclude:test1"});
|
|
|
|
CHECK(result);
|
|
|
|
|
|
|
|
Catch::Config cfg(config);
|
2018-02-08 23:18:32 +01:00
|
|
|
REQUIRE(cfg.hasTestFilters());
|
2019-11-04 21:35:57 +01:00
|
|
|
REQUIRE(cfg.testSpec().matches(*fakeTestCase("test1")) == false);
|
|
|
|
REQUIRE(cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")));
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("Specify one test case exclusion using ~") {
|
|
|
|
auto result = cli.parse({"test", "~test1"});
|
|
|
|
CHECK(result);
|
|
|
|
|
|
|
|
Catch::Config cfg(config);
|
2018-02-08 23:18:32 +01:00
|
|
|
REQUIRE(cfg.hasTestFilters());
|
2019-11-04 21:35:57 +01:00
|
|
|
REQUIRE(cfg.testSpec().matches(*fakeTestCase("test1")) == false);
|
|
|
|
REQUIRE(cfg.testSpec().matches(*fakeTestCase("alwaysIncluded")));
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("reporter") {
|
2022-04-04 21:07:04 +02:00
|
|
|
using vec_Specs = std::vector<Catch::ReporterSpec>;
|
2021-02-06 20:12:07 +01:00
|
|
|
using namespace std::string_literals;
|
2017-11-13 17:03:27 +01:00
|
|
|
SECTION("-r/console") {
|
2021-02-06 20:12:07 +01:00
|
|
|
auto result = cli.parse({"test", "-r", "console"});
|
|
|
|
CAPTURE(result.errorMessage());
|
|
|
|
CHECK(result);
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2022-04-04 21:07:04 +02:00
|
|
|
REQUIRE( config.reporterSpecifications ==
|
|
|
|
vec_Specs{ { "console", {}, {}, {} } } );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
SECTION("-r/xml") {
|
2021-02-06 20:12:07 +01:00
|
|
|
auto result = cli.parse({"test", "-r", "xml"});
|
|
|
|
CAPTURE(result.errorMessage());
|
|
|
|
CHECK(result);
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2022-04-04 21:07:04 +02:00
|
|
|
REQUIRE( config.reporterSpecifications ==
|
|
|
|
vec_Specs{ { "xml", {}, {}, {} } } );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
SECTION("--reporter/junit") {
|
2021-02-06 20:12:07 +01:00
|
|
|
auto result = cli.parse({"test", "--reporter", "junit"});
|
|
|
|
CAPTURE(result.errorMessage());
|
|
|
|
CHECK(result);
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2022-04-04 21:07:04 +02:00
|
|
|
REQUIRE( config.reporterSpecifications ==
|
|
|
|
vec_Specs{ { "junit", {}, {}, {} } } );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
2018-10-22 15:59:01 +02:00
|
|
|
SECTION("must match one of the available ones") {
|
|
|
|
auto result = cli.parse({"test", "--reporter", "unsupported"});
|
|
|
|
CHECK(!result);
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2021-09-23 23:28:59 +02:00
|
|
|
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Unrecognized reporter"));
|
2018-10-22 15:59:01 +02:00
|
|
|
}
|
2021-02-06 20:12:07 +01:00
|
|
|
SECTION("With output file") {
|
2022-04-04 21:07:04 +02:00
|
|
|
auto result = cli.parse({ "test", "-r", "console::out=out.txt" });
|
2021-02-06 20:12:07 +01:00
|
|
|
CAPTURE(result.errorMessage());
|
|
|
|
CHECK(result);
|
2022-04-04 21:07:04 +02:00
|
|
|
REQUIRE( config.reporterSpecifications ==
|
|
|
|
vec_Specs{ { "console", "out.txt"s, {}, {} } } );
|
2021-02-06 20:12:07 +01:00
|
|
|
}
|
|
|
|
SECTION("With Windows-like absolute path as output file") {
|
2022-04-04 21:07:04 +02:00
|
|
|
auto result = cli.parse({ "test", "-r", "console::out=C:\\Temp\\out.txt" });
|
2021-02-06 20:12:07 +01:00
|
|
|
CAPTURE(result.errorMessage());
|
|
|
|
CHECK(result);
|
2022-04-04 21:07:04 +02:00
|
|
|
REQUIRE( config.reporterSpecifications ==
|
|
|
|
vec_Specs{ { "console", "C:\\Temp\\out.txt"s, {}, {} } } );
|
2021-02-06 20:12:07 +01:00
|
|
|
}
|
|
|
|
SECTION("Multiple reporters") {
|
|
|
|
SECTION("All with output files") {
|
2022-04-04 21:07:04 +02:00
|
|
|
CHECK(cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "junit::out=output-junit.xml" }));
|
|
|
|
REQUIRE( config.reporterSpecifications ==
|
|
|
|
vec_Specs{ { "xml", "output.xml"s, {}, {} },
|
|
|
|
{ "junit", "output-junit.xml"s, {}, {} } } );
|
2021-02-06 20:12:07 +01:00
|
|
|
}
|
|
|
|
SECTION("Mixed output files and default output") {
|
2022-04-04 21:07:04 +02:00
|
|
|
CHECK(cli.parse({ "test", "-r", "xml::out=output.xml", "-r", "console" }));
|
|
|
|
REQUIRE( config.reporterSpecifications ==
|
|
|
|
vec_Specs{ { "xml", "output.xml"s, {}, {} },
|
|
|
|
{ "console", {}, {}, {} } } );
|
2021-02-06 20:12:07 +01:00
|
|
|
}
|
|
|
|
SECTION("cannot have multiple reporters with default output") {
|
2022-04-04 21:07:04 +02:00
|
|
|
auto result = cli.parse({ "test", "-r", "console", "-r", "xml::out=output.xml", "-r", "junit" });
|
2021-02-06 20:12:07 +01:00
|
|
|
CHECK(!result);
|
|
|
|
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Only one reporter may have unspecified output file."));
|
|
|
|
}
|
|
|
|
}
|
2018-10-22 15:59:01 +02:00
|
|
|
}
|
2017-11-13 17:03:27 +01:00
|
|
|
|
|
|
|
SECTION("debugger") {
|
|
|
|
SECTION("-b") {
|
|
|
|
CHECK(cli.parse({"test", "-b"}));
|
|
|
|
|
|
|
|
REQUIRE(config.shouldDebugBreak == true);
|
|
|
|
}
|
|
|
|
SECTION("--break") {
|
|
|
|
CHECK(cli.parse({"test", "--break"}));
|
|
|
|
|
|
|
|
REQUIRE(config.shouldDebugBreak);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
SECTION("abort") {
|
|
|
|
SECTION("-a aborts after first failure") {
|
|
|
|
CHECK(cli.parse({"test", "-a"}));
|
|
|
|
|
|
|
|
REQUIRE(config.abortAfter == 1);
|
|
|
|
}
|
|
|
|
SECTION("-x 2 aborts after two failures") {
|
|
|
|
CHECK(cli.parse({"test", "-x", "2"}));
|
|
|
|
|
|
|
|
REQUIRE(config.abortAfter == 2);
|
|
|
|
}
|
|
|
|
SECTION("-x must be numeric") {
|
|
|
|
auto result = cli.parse({"test", "-x", "oops"});
|
|
|
|
CHECK(!result);
|
2021-09-23 23:28:59 +02:00
|
|
|
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("convert") && ContainsSubstring("oops"));
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
2020-02-15 20:42:57 +01:00
|
|
|
|
|
|
|
SECTION("wait-for-keypress") {
|
|
|
|
SECTION("Accepted options") {
|
|
|
|
using tuple_type = std::tuple<char const*, Catch::WaitForKeypress::When>;
|
|
|
|
auto input = GENERATE(table<char const*, Catch::WaitForKeypress::When>({
|
|
|
|
tuple_type{"never", Catch::WaitForKeypress::Never},
|
|
|
|
tuple_type{"start", Catch::WaitForKeypress::BeforeStart},
|
|
|
|
tuple_type{"exit", Catch::WaitForKeypress::BeforeExit},
|
|
|
|
tuple_type{"both", Catch::WaitForKeypress::BeforeStartAndExit},
|
|
|
|
}));
|
|
|
|
CHECK(cli.parse({"test", "--wait-for-keypress", std::get<0>(input)}));
|
|
|
|
|
|
|
|
REQUIRE(config.waitForKeypress == std::get<1>(input));
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("invalid options are reported") {
|
|
|
|
auto result = cli.parse({"test", "--wait-for-keypress", "sometimes"});
|
|
|
|
CHECK(!result);
|
|
|
|
|
|
|
|
#ifndef CATCH_CONFIG_DISABLE_MATCHERS
|
2021-09-23 23:28:59 +02:00
|
|
|
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("never") && ContainsSubstring("both"));
|
2020-02-15 20:42:57 +01:00
|
|
|
#endif
|
|
|
|
}
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
2020-02-15 20:42:57 +01:00
|
|
|
}
|
2017-11-13 17:03:27 +01:00
|
|
|
|
|
|
|
SECTION("nothrow") {
|
|
|
|
SECTION("-e") {
|
|
|
|
CHECK(cli.parse({"test", "-e"}));
|
|
|
|
|
|
|
|
REQUIRE(config.noThrow);
|
|
|
|
}
|
|
|
|
SECTION("--nothrow") {
|
|
|
|
CHECK(cli.parse({"test", "--nothrow"}));
|
|
|
|
|
|
|
|
REQUIRE(config.noThrow);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("output filename") {
|
|
|
|
SECTION("-o filename") {
|
|
|
|
CHECK(cli.parse({"test", "-o", "filename.ext"}));
|
|
|
|
|
2021-02-06 20:12:07 +01:00
|
|
|
REQUIRE(config.defaultOutputFilename == "filename.ext");
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
SECTION("--out") {
|
|
|
|
CHECK(cli.parse({"test", "--out", "filename.ext"}));
|
|
|
|
|
2021-02-06 20:12:07 +01:00
|
|
|
REQUIRE(config.defaultOutputFilename == "filename.ext");
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("combinations") {
|
|
|
|
SECTION("Single character flags can be combined") {
|
|
|
|
CHECK(cli.parse({"test", "-abe"}));
|
|
|
|
|
|
|
|
CHECK(config.abortAfter == 1);
|
|
|
|
CHECK(config.shouldDebugBreak);
|
|
|
|
CHECK(config.noThrow == true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
SECTION( "use-colour") {
|
|
|
|
|
2022-03-27 23:35:41 +02:00
|
|
|
using Catch::ColourMode;
|
2017-11-13 17:03:27 +01:00
|
|
|
|
|
|
|
SECTION( "without option" ) {
|
|
|
|
CHECK(cli.parse({"test"}));
|
|
|
|
|
2022-04-06 21:56:29 +02:00
|
|
|
REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION( "auto" ) {
|
2022-03-27 23:35:41 +02:00
|
|
|
CHECK( cli.parse( { "test", "--colour-mode", "default" } ) );
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2022-04-06 21:56:29 +02:00
|
|
|
REQUIRE( config.defaultColourMode == ColourMode::PlatformDefault );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION( "yes" ) {
|
2022-03-27 23:35:41 +02:00
|
|
|
CHECK(cli.parse({"test", "--colour-mode", "ansi"}));
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2022-04-06 21:56:29 +02:00
|
|
|
REQUIRE( config.defaultColourMode == ColourMode::ANSI );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION( "no" ) {
|
2022-03-27 23:35:41 +02:00
|
|
|
CHECK(cli.parse({"test", "--colour-mode", "none"}));
|
2017-11-13 17:03:27 +01:00
|
|
|
|
2022-04-06 21:56:29 +02:00
|
|
|
REQUIRE( config.defaultColourMode == ColourMode::None );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION( "error" ) {
|
2022-03-27 23:35:41 +02:00
|
|
|
auto result = cli.parse({"test", "--colour-mode", "wrong"});
|
2017-11-13 17:03:27 +01:00
|
|
|
CHECK( !result );
|
2021-09-23 23:28:59 +02:00
|
|
|
CHECK_THAT( result.errorMessage(), ContainsSubstring( "colour mode must be one of" ) );
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
|
|
|
}
|
2019-04-23 23:41:13 +02:00
|
|
|
|
|
|
|
SECTION("Benchmark options") {
|
|
|
|
SECTION("samples") {
|
|
|
|
CHECK(cli.parse({ "test", "--benchmark-samples=200" }));
|
|
|
|
|
|
|
|
REQUIRE(config.benchmarkSamples == 200);
|
|
|
|
}
|
2019-06-22 20:26:03 +02:00
|
|
|
|
2019-04-23 23:41:13 +02:00
|
|
|
SECTION("resamples") {
|
|
|
|
CHECK(cli.parse({ "test", "--benchmark-resamples=20000" }));
|
|
|
|
|
|
|
|
REQUIRE(config.benchmarkResamples == 20000);
|
|
|
|
}
|
|
|
|
|
2020-01-27 15:43:27 +01:00
|
|
|
SECTION("confidence-interval") {
|
2019-04-23 23:41:13 +02:00
|
|
|
CHECK(cli.parse({ "test", "--benchmark-confidence-interval=0.99" }));
|
|
|
|
|
2020-02-03 15:07:59 +01:00
|
|
|
REQUIRE(config.benchmarkConfidenceInterval == Catch::Approx(0.99));
|
2019-04-23 23:41:13 +02:00
|
|
|
}
|
|
|
|
|
2020-01-27 15:43:27 +01:00
|
|
|
SECTION("no-analysis") {
|
2019-04-23 23:41:13 +02:00
|
|
|
CHECK(cli.parse({ "test", "--benchmark-no-analysis" }));
|
|
|
|
|
|
|
|
REQUIRE(config.benchmarkNoAnalysis);
|
|
|
|
}
|
2020-01-27 15:43:27 +01:00
|
|
|
|
|
|
|
SECTION("warmup-time") {
|
|
|
|
CHECK(cli.parse({ "test", "--benchmark-warmup-time=10" }));
|
|
|
|
|
|
|
|
REQUIRE(config.benchmarkWarmupTime == 10);
|
|
|
|
}
|
2019-04-23 23:41:13 +02:00
|
|
|
}
|
2021-10-26 23:26:07 +02:00
|
|
|
}
|
2021-07-11 21:46:05 +02:00
|
|
|
|
2021-10-26 23:26:07 +02:00
|
|
|
TEST_CASE("Parsing sharding-related cli flags", "[sharding]") {
|
|
|
|
using namespace Catch::Matchers;
|
2021-07-11 21:46:05 +02:00
|
|
|
|
2021-10-26 23:26:07 +02:00
|
|
|
Catch::ConfigData config;
|
|
|
|
auto cli = Catch::makeCommandLineParser(config);
|
2021-07-11 21:46:05 +02:00
|
|
|
|
2021-10-26 23:26:07 +02:00
|
|
|
SECTION("shard-count") {
|
|
|
|
CHECK(cli.parse({ "test", "--shard-count=8" }));
|
2021-07-11 21:46:05 +02:00
|
|
|
|
2021-10-26 23:26:07 +02:00
|
|
|
REQUIRE(config.shardCount == 8);
|
|
|
|
}
|
2021-07-11 21:46:05 +02:00
|
|
|
|
2021-10-26 23:26:07 +02:00
|
|
|
SECTION("Negative shard count reports error") {
|
|
|
|
auto result = cli.parse({ "test", "--shard-count=-1" });
|
2021-07-11 21:46:05 +02:00
|
|
|
|
2021-10-26 23:26:07 +02:00
|
|
|
CHECK_FALSE(result);
|
|
|
|
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Shard count must be a positive number"));
|
|
|
|
}
|
|
|
|
|
|
|
|
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"));
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("shard-index") {
|
|
|
|
CHECK(cli.parse({ "test", "--shard-index=2" }));
|
|
|
|
|
|
|
|
REQUIRE(config.shardIndex == 2);
|
2021-07-11 21:46:05 +02:00
|
|
|
}
|
2021-10-26 23:26:07 +02:00
|
|
|
|
|
|
|
SECTION("Negative shard index reports error") {
|
|
|
|
auto result = cli.parse({ "test", "--shard-index=-12" });
|
|
|
|
|
|
|
|
CHECK_FALSE(result);
|
|
|
|
REQUIRE_THAT(result.errorMessage(), ContainsSubstring("Shard index must be a non-negative number"));
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("Shard index 0 is accepted") {
|
|
|
|
CHECK(cli.parse({ "test", "--shard-index=0" }));
|
|
|
|
|
|
|
|
REQUIRE(config.shardIndex == 0);
|
|
|
|
}
|
|
|
|
|
2017-11-13 17:03:27 +01:00
|
|
|
}
|
2019-09-21 00:11:45 +02:00
|
|
|
|
2021-12-18 20:48:43 +01:00
|
|
|
TEST_CASE( "Parsing warnings", "[cli][warnings]" ) {
|
|
|
|
using Catch::WarnAbout;
|
|
|
|
|
|
|
|
Catch::ConfigData config;
|
|
|
|
auto cli = Catch::makeCommandLineParser( config );
|
|
|
|
|
|
|
|
SECTION( "NoAssertions" ) {
|
|
|
|
REQUIRE(cli.parse( { "test", "-w", "NoAssertions" } ));
|
|
|
|
REQUIRE( config.warnings == WarnAbout::NoAssertions );
|
|
|
|
}
|
|
|
|
SECTION( "NoTests is no longer supported" ) {
|
|
|
|
REQUIRE_FALSE(cli.parse( { "test", "-w", "NoTests" } ));
|
|
|
|
}
|
|
|
|
SECTION( "Combining multiple warnings" ) {
|
|
|
|
REQUIRE( cli.parse( { "test",
|
|
|
|
"--warn", "NoAssertions",
|
|
|
|
"--warn", "UnmatchedTestSpec" } ) );
|
|
|
|
|
|
|
|
REQUIRE( config.warnings == ( WarnAbout::NoAssertions | WarnAbout::UnmatchedTestSpec ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-21 00:11:45 +02:00
|
|
|
TEST_CASE("Test with special, characters \"in name", "[cli][regression]") {
|
|
|
|
// This test case succeeds if we can invoke it from the CLI
|
|
|
|
SUCCEED();
|
|
|
|
}
|
2021-12-30 23:50:40 +01:00
|
|
|
|
|
|
|
TEST_CASE("Various suspicious reporter specs are rejected",
|
|
|
|
"[cli][reporter-spec][approvals]") {
|
|
|
|
Catch::ConfigData config;
|
|
|
|
auto cli = Catch::makeCommandLineParser( config );
|
|
|
|
|
|
|
|
auto spec = GENERATE( as<std::string>{},
|
|
|
|
"",
|
|
|
|
"::console",
|
|
|
|
"console::",
|
|
|
|
"console::some-file::",
|
|
|
|
"::console::some-file::" );
|
|
|
|
CAPTURE( spec );
|
|
|
|
|
|
|
|
auto result = cli.parse( { "test", "--reporter", spec } );
|
|
|
|
REQUIRE_FALSE( result );
|
|
|
|
}
|
2022-03-27 23:35:41 +02:00
|
|
|
|
|
|
|
TEST_CASE("Win32 colour implementation is compile-time optional",
|
|
|
|
"[approvals][cli][colours]") {
|
|
|
|
Catch::ConfigData config;
|
|
|
|
auto cli = Catch::makeCommandLineParser( config );
|
|
|
|
|
|
|
|
auto result = cli.parse( { "test", "--colour-mode", "win32" } );
|
|
|
|
|
|
|
|
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
|
|
|
|
REQUIRE( result );
|
|
|
|
#else
|
|
|
|
REQUIRE_FALSE( result );
|
|
|
|
#endif
|
|
|
|
}
|
2022-10-22 17:04:08 +02:00
|
|
|
|
|
|
|
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 } ) );
|
|
|
|
}
|
|
|
|
}
|