mirror of
https://github.com/catchorg/Catch2.git
synced 2024-11-22 21:36:11 +01:00
e1e6872c4c
This is both a really big and a really small commit. It is small in
that it only contains renaming, moving and modification of include
directives caused by this.
It is really big in the obvious way of touching something like 200
files.
The new rules for naming files is simple: headers use the `.hpp`
extension. The rules for physical file layout is still kinda in
progress, but the basics are also simple:
* Significant parts of functionality get their own subfolder
* Benchmarking is in `catch2/benchmark`
* Matchers are in `catch2/matchers`
* Generators are in `catch2/generators`
* Reporters are in `catch2/reporters`
* Baseline testing facilities are in `catch2/`
* Various top level folders also contain `internal` subfolder,
with files that users probably do not want to include directly,
at least not until they have to write something like their own
reporter.
* The exact files in these subfolders is likely to change later
on
Note that while some includes were cleaned up in this commit, it
is only the low hanging fruit and further cleanup using automatic
tooling will happen later.
Also note that various include guards, copyright notices and file
headers will also be standardized later, rather than in this commit.
101 lines
3.4 KiB
C++
101 lines
3.4 KiB
C++
#include <catch2/catch_test_macros.hpp>
|
|
#include <catch2/internal/catch_enum_values_registry.hpp>
|
|
|
|
|
|
namespace {
|
|
// Enum without user-provided stream operator
|
|
enum Enum1 { Enum1Value0, Enum1Value1 };
|
|
|
|
// Enum with user-provided stream operator
|
|
enum Enum2 { Enum2Value0, Enum2Value1 };
|
|
|
|
std::ostream& operator<<( std::ostream& os, Enum2 v ) {
|
|
return os << "E2{" << static_cast<int>(v) << "}";
|
|
}
|
|
} // end anonymous namespace
|
|
|
|
TEST_CASE( "toString(enum)", "[toString][enum]" ) {
|
|
Enum1 e0 = Enum1Value0;
|
|
CHECK( ::Catch::Detail::stringify(e0) == "0" );
|
|
Enum1 e1 = Enum1Value1;
|
|
CHECK( ::Catch::Detail::stringify(e1) == "1" );
|
|
}
|
|
|
|
TEST_CASE( "toString(enum w/operator<<)", "[toString][enum]" ) {
|
|
Enum2 e0 = Enum2Value0;
|
|
CHECK( ::Catch::Detail::stringify(e0) == "E2{0}" );
|
|
Enum2 e1 = Enum2Value1;
|
|
CHECK( ::Catch::Detail::stringify(e1) == "E2{1}" );
|
|
}
|
|
|
|
// Enum class without user-provided stream operator
|
|
namespace {
|
|
enum class EnumClass1 { EnumClass1Value0, EnumClass1Value1 };
|
|
|
|
// Enum class with user-provided stream operator
|
|
enum class EnumClass2 { EnumClass2Value0, EnumClass2Value1 };
|
|
|
|
std::ostream& operator<<( std::ostream& os, EnumClass2 e2 ) {
|
|
switch( static_cast<int>( e2 ) ) {
|
|
case static_cast<int>( EnumClass2::EnumClass2Value0 ):
|
|
return os << "E2/V0";
|
|
case static_cast<int>( EnumClass2::EnumClass2Value1 ):
|
|
return os << "E2/V1";
|
|
default:
|
|
return os << "Unknown enum value " << static_cast<int>( e2 );
|
|
}
|
|
}
|
|
|
|
} // end anonymous namespace
|
|
|
|
TEST_CASE( "toString(enum class)", "[toString][enum][enumClass]" ) {
|
|
EnumClass1 e0 = EnumClass1::EnumClass1Value0;
|
|
CHECK( ::Catch::Detail::stringify(e0) == "0" );
|
|
EnumClass1 e1 = EnumClass1::EnumClass1Value1;
|
|
CHECK( ::Catch::Detail::stringify(e1) == "1" );
|
|
}
|
|
|
|
|
|
TEST_CASE( "toString(enum class w/operator<<)", "[toString][enum][enumClass]" ) {
|
|
EnumClass2 e0 = EnumClass2::EnumClass2Value0;
|
|
CHECK( ::Catch::Detail::stringify(e0) == "E2/V0" );
|
|
EnumClass2 e1 = EnumClass2::EnumClass2Value1;
|
|
CHECK( ::Catch::Detail::stringify(e1) == "E2/V1" );
|
|
|
|
auto e3 = static_cast<EnumClass2>(10);
|
|
CHECK( ::Catch::Detail::stringify(e3) == "Unknown enum value 10" );
|
|
}
|
|
|
|
enum class EnumClass3 { Value1, Value2, Value3, Value4 };
|
|
|
|
CATCH_REGISTER_ENUM( EnumClass3, EnumClass3::Value1, EnumClass3::Value2, EnumClass3::Value3 )
|
|
|
|
|
|
TEST_CASE( "Enums can quickly have stringification enabled using REGISTER_ENUM" ) {
|
|
using Catch::Detail::stringify;
|
|
REQUIRE( stringify( EnumClass3::Value1 ) == "Value1" );
|
|
REQUIRE( stringify( EnumClass3::Value2 ) == "Value2" );
|
|
REQUIRE( stringify( EnumClass3::Value3 ) == "Value3" );
|
|
REQUIRE( stringify( EnumClass3::Value4 ) == "{** unexpected enum value **}" );
|
|
|
|
EnumClass3 ec3 = EnumClass3 ::Value2;
|
|
REQUIRE( stringify( ec3 ) == "Value2" );
|
|
}
|
|
|
|
namespace Bikeshed {
|
|
enum class Colours { Red, Green, Blue };
|
|
}
|
|
|
|
// Important!: This macro must appear at top level scope - not inside a namespace
|
|
// You can fully qualify the names, or use a using if you prefer
|
|
CATCH_REGISTER_ENUM( Bikeshed::Colours,
|
|
Bikeshed::Colours::Red,
|
|
Bikeshed::Colours::Green,
|
|
Bikeshed::Colours::Blue )
|
|
|
|
TEST_CASE( "Enums in namespaces can quickly have stringification enabled using REGISTER_ENUM" ) {
|
|
using Catch::Detail::stringify;
|
|
REQUIRE( stringify( Bikeshed::Colours::Red ) == "Red" );
|
|
REQUIRE( stringify( Bikeshed::Colours::Blue ) == "Blue" );
|
|
}
|