3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2025-11-04 05:59:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

Remove the ill-conceived compilation perf tests using real tests

Browse Source
This commit is contained in:
Martin Hořeňovský
2021-06-20 16:25:57 +02:00
parent 849002aec0
commit bf61a418cb
19 changed files with 2228 additions and 2276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
tests/SelfTest/UsageTests/Compilation.tests.cpp
View File

@@ -33,60 +33,44 @@ std::ostream& operator<<(std::ostream& out, foo::helper_1403 const&) {
#include <cstring>
namespace { namespace CompilationTests {
#ifndef COMPILATION_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
#define COMPILATION_TEST_HELPERS_INCLUDED
// Comparison operators can return non-booleans.
// This is unusual, but should be supported.
struct logic_t {
logic_t operator< (logic_t) const { return {}; }
logic_t operator<=(logic_t) const { return {}; }
logic_t operator> (logic_t) const { return {}; }
logic_t operator>=(logic_t) const { return {}; }
logic_t operator==(logic_t) const { return {}; }
logic_t operator!=(logic_t) const { return {}; }
explicit operator bool() const { return true; }
};
// Comparison operators can return non-booleans.
// This is unusual, but should be supported.
struct logic_t {
logic_t operator< (logic_t) const { return {}; }
logic_t operator<=(logic_t) const { return {}; }
logic_t operator> (logic_t) const { return {}; }
logic_t operator>=(logic_t) const { return {}; }
logic_t operator==(logic_t) const { return {}; }
logic_t operator!=(logic_t) const { return {}; }
explicit operator bool() const { return true; }
};
// This is a minimal example for an issue we have found in 1.7.0
struct foo {
int i;
};
template<typename T>
bool operator==(const T &val, foo f) {
return val == f.i;
void throws_int(bool b) {
if (b) {
throw 1;
}
}
void throws_int(bool b) {
if (b) {
throw 1;
}
}
template<typename T>
bool templated_tests(T t) {
int a = 3;
REQUIRE(a == t);
CHECK(a == t);
REQUIRE_THROWS(throws_int(true));
CHECK_THROWS_AS(throws_int(true), int);
REQUIRE_NOTHROW(throws_int(false));
REQUIRE_THAT("aaa", Catch::Matchers::EndsWith("aaa"));
return true;
}
template<typename T>
bool templated_tests(T t) {
int a = 3;
REQUIRE(a == t);
CHECK(a == t);
REQUIRE_THROWS(throws_int(true));
CHECK_THROWS_AS(throws_int(true), int);
REQUIRE_NOTHROW(throws_int(false));
REQUIRE_THAT("aaa", Catch::Matchers::EndsWith("aaa"));
return true;
}
struct A {};
struct A {
};
std::ostream &operator<<(std::ostream &o, const A &) { return o << 0; }
std::ostream &operator<<(std::ostream &o, const A &) { return o << 0; }
struct B : private A {
bool operator==(int) const { return true; }
};
struct B : private A {
bool operator==(int) const { return true; }
};
#ifdef __clang__
#pragma clang diagnostic push
@@ -98,24 +82,32 @@ namespace { namespace CompilationTests {
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
B f();
B f();
std::ostream g();
std::ostream g();
#ifdef __clang__
#pragma clang diagnostic pop
#endif
template <typename, typename>
struct Fixture_1245 {};
template <typename, typename>
struct Fixture_1245 {};
#endif
// This is a minimal example for an issue we have found in 1.7.0
struct dummy_809 {
int i;
};
TEST_CASE("#809") {
foo f;
f.i = 42;
REQUIRE(42 == f);
}
template<typename T>
bool operator==(const T& val, dummy_809 f) {
return val == f.i;
}
TEST_CASE("#809") {
dummy_809 f;
f.i = 42;
REQUIRE(42 == f);
}
// ------------------------------------------------------------------
@@ -129,65 +121,63 @@ namespace { namespace CompilationTests {
// Test containing example where original stream insertable check breaks compilation
TEST_CASE("#872") {
A dummy;
CAPTURE(dummy);
B x;
REQUIRE (x == 4);
}
TEST_CASE("#1027: Bitfields can be captured") {
struct Y {
uint32_t v : 1;
};
Y y{ 0 };
REQUIRE(y.v == 0);
REQUIRE(0 == y.v);
}
TEST_CASE("#872") {
A dummy;
CAPTURE(dummy);
B x;
REQUIRE (x == 4);
}
// Comparison operators can return non-booleans.
// This is unusual, but should be supported.
TEST_CASE("#1147") {
logic_t t1, t2;
REQUIRE(t1 == t2);
REQUIRE(t1 != t2);
REQUIRE(t1 < t2);
REQUIRE(t1 > t2);
REQUIRE(t1 <= t2);
REQUIRE(t1 >= t2);
}
TEST_CASE("#1027: Bitfields can be captured") {
struct Y {
uint32_t v : 1;
};
Y y{ 0 };
REQUIRE(y.v == 0);
REQUIRE(0 == y.v);
}
// unsigned array
TEST_CASE("#1238") {
unsigned char uarr[] = "123";
CAPTURE(uarr);
signed char sarr[] = "456";
CAPTURE(sarr);
// Comparison operators can return non-booleans.
// This is unusual, but should be supported.
TEST_CASE("#1147") {
logic_t t1, t2;
REQUIRE(t1 == t2);
REQUIRE(t1 != t2);
REQUIRE(t1 < t2);
REQUIRE(t1 > t2);
REQUIRE(t1 <= t2);
REQUIRE(t1 >= t2);
}
REQUIRE(std::memcmp(uarr, "123", sizeof(uarr)) == 0);
REQUIRE(std::memcmp(sarr, "456", sizeof(sarr)) == 0);
}
// unsigned array
TEST_CASE("#1238") {
unsigned char uarr[] = "123";
CAPTURE(uarr);
signed char sarr[] = "456";
CAPTURE(sarr);
TEST_CASE_METHOD((Fixture_1245<int, int>), "#1245", "[compilation]") {
SUCCEED();
}
REQUIRE(std::memcmp(uarr, "123", sizeof(uarr)) == 0);
REQUIRE(std::memcmp(sarr, "456", sizeof(sarr)) == 0);
}
TEST_CASE("#1403", "[compilation]") {
::foo::helper_1403 h1, h2;
REQUIRE(h1 == h2);
}
TEST_CASE_METHOD((Fixture_1245<int, int>), "#1245", "[compilation]") {
SUCCEED();
}
TEST_CASE("Optionally static assertions", "[compilation]") {
STATIC_REQUIRE( std::is_void<void>::value );
STATIC_REQUIRE_FALSE( std::is_void<int>::value );
}
TEST_CASE("#1403", "[compilation]") {
::foo::helper_1403 h1, h2;
REQUIRE(h1 == h2);
}
TEST_CASE("Optionally static assertions", "[compilation]") {
STATIC_REQUIRE( std::is_void<void>::value );
STATIC_REQUIRE_FALSE( std::is_void<int>::value );
}
TEST_CASE("#1548", "[compilation]") {
using namespace bar;
REQUIRE(std::is_same<TypeList<int>, TypeList<int>>::value);
}
TEST_CASE("#1548", "[compilation]") {
using namespace bar;
REQUIRE(std::is_same<TypeList<int>, TypeList<int>>::value);
}
// #925
using signal_t = void (*) (void*);
@@ -214,17 +204,16 @@ namespace { namespace CompilationTests {
#pragma warning(pop)
#endif
TEST_CASE("#1319: Sections can have description (even if it is not saved", "[compilation]") {
SECTION("SectionName", "This is a long form section description") {
SUCCEED();
}
TEST_CASE( "#1319: Sections can have description (even if it is not saved",
"[compilation]" ) {
SECTION( "SectionName", "This is a long form section description" ) {
SUCCEED();
}
}
TEST_CASE("Lambdas in assertions") {
REQUIRE([]() { return true; }());
}
}} // namespace CompilationTests
TEST_CASE("Lambdas in assertions") {
REQUIRE([]() { return true; }());
}
namespace {
struct HasBitOperators {