Skip to content

Commit

Permalink
Prefix catch2 macros with CATCH_
Browse files Browse the repository at this point in the history
  • Loading branch information
@gmgunter
gmgunter committed Aug 5, 2024
1 parent 61a9822 commit d49de3f
Show file tree
Hide file tree
Showing 9 changed files with 156 additions and 152 deletions.
3 changes: 1 addition & 2 deletions .clang-tidy
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,6 @@ Checks: >
-android-*,
-boost-*,
-cert-dcl58-cpp,
-cppcoreguidelines-macro-usage,
-fuchsia-default-arguments-*,
-fuchsia-overloaded-operator,
-fuchsia-trailing-return,
Expand All @@ -23,7 +22,7 @@ CheckOptions:
- key: bugprone-easily-swappable-parameters.MinimumLength
value: 4
- key: cppcoreguidelines-macro-usage.AllowedRegexp
value: "^WHIRLWIND_[A-Z_]+$"
value: "^(CATCH|WHIRLWIND)_[A-Z_]+$"
- key: hicpp-multiway-paths-covered.WarnOnMissingElse
value: true
- key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
Expand Down
1 change: 1 addition & 0 deletions test/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,7 @@ target_link_libraries(
test-whirlwind PRIVATE Catch2::Catch2WithMain whirlwind::warnings
whirlwind::whirlwind
)
target_compile_definitions(test-whirlwind PRIVATE CATCH_CONFIG_PREFIX_ALL)
set_target_properties(test-whirlwind PROPERTIES CXX_SCAN_FOR_MODULES OFF)

# Find and register test cases from `test-whirlwind` with CTest.
Expand Down
19 changes: 10 additions & 9 deletions test/common/test_version.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,23 +8,24 @@

namespace {

TEST_CASE("WHIRLWIND_VERSION_EPOCH", "[version]")
CATCH_TEST_CASE("WHIRLWIND_VERSION_EPOCH", "[version]")
{
STATIC_REQUIRE((std::is_same_v<decltype(WHIRLWIND_VERSION_EPOCH), unsigned long>));
STATIC_REQUIRE(WHIRLWIND_VERSION_EPOCH >= 20240101UL);
STATIC_REQUIRE(WHIRLWIND_VERSION_EPOCH <= 99999999UL);
using T = decltype(WHIRLWIND_VERSION_EPOCH);
CATCH_STATIC_REQUIRE((std::is_same_v<T, unsigned long>));
CATCH_STATIC_REQUIRE(WHIRLWIND_VERSION_EPOCH >= 20240101UL);
CATCH_STATIC_REQUIRE(WHIRLWIND_VERSION_EPOCH <= 99999999UL);
}

TEST_CASE("WHIRLWIND_VERSION_PATCH", "[version]")
CATCH_TEST_CASE("WHIRLWIND_VERSION_PATCH", "[version]")
{
STATIC_REQUIRE((std::is_same_v<decltype(WHIRLWIND_VERSION_PATCH), unsigned>));
STATIC_REQUIRE(WHIRLWIND_VERSION_PATCH >= 0U);
CATCH_STATIC_REQUIRE((std::is_same_v<decltype(WHIRLWIND_VERSION_PATCH), unsigned>));
CATCH_STATIC_REQUIRE(WHIRLWIND_VERSION_PATCH >= 0U);
}

TEST_CASE("WHIRLWIND_VERSION_STRING", "[version]")
CATCH_TEST_CASE("WHIRLWIND_VERSION_STRING", "[version]")
{
using Catch::Matchers::Matches;
CHECK_THAT(WHIRLWIND_VERSION_STRING, Matches(R"(^\d{8}\.\d+$)"));
CATCH_CHECK_THAT(WHIRLWIND_VERSION_STRING, Matches(R"(^\d{8}\.\d+$)"));
}

} // namespace
132 changes: 66 additions & 66 deletions test/graph/csr_graph.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,24 +12,24 @@ namespace {

namespace ww = whirlwind;

TEST_CASE("CSRGraph (empty)", "[graph]")
CATCH_TEST_CASE("CSRGraph (empty)", "[graph]")
{
const auto graph = ww::CSRGraph();

SECTION("num_{vertices,edges}")
CATCH_SECTION("num_{vertices,edges}")
{
CHECK(graph.num_vertices() == 0U);
CHECK(graph.num_edges() == 0U);
CATCH_CHECK(graph.num_vertices() == 0U);
CATCH_CHECK(graph.num_edges() == 0U);
}

SECTION("contains_{vertex,edge}")
CATCH_SECTION("contains_{vertex,edge}")
{
CHECK_FALSE(graph.contains_vertex(0U));
CHECK_FALSE(graph.contains_edge(0U));
CATCH_CHECK_FALSE(graph.contains_vertex(0U));
CATCH_CHECK_FALSE(graph.contains_edge(0U));
}
}

TEST_CASE("CSRGraph", "[graph]")
CATCH_TEST_CASE("CSRGraph", "[graph]")
{
auto edgelist = ww::EdgeList();
edgelist.add_edge(0U, 1U);
Expand All @@ -43,64 +43,64 @@ TEST_CASE("CSRGraph", "[graph]")
const auto vertices = {0U, 1U, 2U, 3U};
const auto edges = {0U, 1U, 2U, 3U, 4U};

SECTION("{vertex,edge,size}_type")
CATCH_SECTION("{vertex,edge,size}_type")
{
using Vertex = typename decltype(graph)::vertex_type;
STATIC_REQUIRE((std::is_same_v<Vertex, std::size_t>));
CATCH_STATIC_REQUIRE((std::is_same_v<Vertex, std::size_t>));

using Edge = typename decltype(graph)::edge_type;
STATIC_REQUIRE((std::is_same_v<Edge, std::size_t>));
CATCH_STATIC_REQUIRE((std::is_same_v<Edge, std::size_t>));

using Size = typename decltype(graph)::size_type;
STATIC_REQUIRE((std::is_same_v<Size, std::size_t>));
CATCH_STATIC_REQUIRE((std::is_same_v<Size, std::size_t>));
}

SECTION("num_{vertices,edges}")
CATCH_SECTION("num_{vertices,edges}")
{
CHECK(graph.num_vertices() == 4U);
CHECK(graph.num_edges() == 5U);
CATCH_CHECK(graph.num_vertices() == 4U);
CATCH_CHECK(graph.num_edges() == 5U);
}

SECTION("get_{vertex,edge}_id")
CATCH_SECTION("get_{vertex,edge}_id")
{
for (const auto& vertex : vertices) {
CHECK(graph.get_vertex_id(vertex) == vertex);
CATCH_CHECK(graph.get_vertex_id(vertex) == vertex);
}
for (const auto& edge : edges) {
CHECK(graph.get_edge_id(edge) == edge);
CATCH_CHECK(graph.get_edge_id(edge) == edge);
}
}

SECTION("{vertices,edges}")
CATCH_SECTION("{vertices,edges}")
{
using Catch::Matchers::RangeEquals;
CHECK_THAT(graph.vertices(), RangeEquals(vertices));
CHECK_THAT(graph.edges(), RangeEquals(edges));
CATCH_CHECK_THAT(graph.vertices(), RangeEquals(vertices));
CATCH_CHECK_THAT(graph.edges(), RangeEquals(edges));
}

SECTION("contains_{vertex,edge}")
CATCH_SECTION("contains_{vertex,edge}")
{
CHECK(graph.contains_vertex(0U));
CHECK(graph.contains_vertex(3U));
CHECK_FALSE(graph.contains_vertex(999U));
CHECK_FALSE(graph.contains_vertex(4U));
CATCH_CHECK(graph.contains_vertex(0U));
CATCH_CHECK(graph.contains_vertex(3U));
CATCH_CHECK_FALSE(graph.contains_vertex(999U));
CATCH_CHECK_FALSE(graph.contains_vertex(4U));

CHECK(graph.contains_edge(0U));
CHECK(graph.contains_edge(4U));
CHECK_FALSE(graph.contains_edge(999U));
CHECK_FALSE(graph.contains_edge(5U));
CATCH_CHECK(graph.contains_edge(0U));
CATCH_CHECK(graph.contains_edge(4U));
CATCH_CHECK_FALSE(graph.contains_edge(999U));
CATCH_CHECK_FALSE(graph.contains_edge(5U));
}

SECTION("outdegree")
CATCH_SECTION("outdegree")
{
CHECK(graph.outdegree(0U) == 3U);
CHECK(graph.outdegree(1U) == 0U);
CHECK(graph.outdegree(2U) == 1U);
CHECK(graph.outdegree(3U) == 1U);
CATCH_CHECK(graph.outdegree(0U) == 3U);
CATCH_CHECK(graph.outdegree(1U) == 0U);
CATCH_CHECK(graph.outdegree(2U) == 1U);
CATCH_CHECK(graph.outdegree(3U) == 1U);
}
}

TEST_CASE("CSRGraph (nonconsecutive vertices)", "[graph]")
CATCH_TEST_CASE("CSRGraph (nonconsecutive vertices)", "[graph]")
{
auto edgelist = ww::EdgeList();
edgelist.add_edge(0U, 1U);
Expand All @@ -109,33 +109,33 @@ TEST_CASE("CSRGraph (nonconsecutive vertices)", "[graph]")

const auto graph = ww::CSRGraph(edgelist);

SECTION("num_{vertices,edges}")
CATCH_SECTION("num_{vertices,edges}")
{
CHECK(graph.num_vertices() == 6U);
CHECK(graph.num_edges() == 3U);
CATCH_CHECK(graph.num_vertices() == 6U);
CATCH_CHECK(graph.num_edges() == 3U);
}

SECTION("{vertices,edges}")
CATCH_SECTION("{vertices,edges}")
{
using Catch::Matchers::RangeEquals;

const auto vertices = {0U, 1U, 2U, 3U, 4U, 5U};
CHECK_THAT(graph.vertices(), RangeEquals(vertices));
CATCH_CHECK_THAT(graph.vertices(), RangeEquals(vertices));

const auto edges = {0U, 1U, 2U};
CHECK_THAT(graph.edges(), RangeEquals(edges));
CATCH_CHECK_THAT(graph.edges(), RangeEquals(edges));
}

SECTION("contains_vertex")
CATCH_SECTION("contains_vertex")
{
CHECK(graph.contains_vertex(3));
CHECK_FALSE(graph.contains_vertex(6));
CATCH_CHECK(graph.contains_vertex(3));
CATCH_CHECK_FALSE(graph.contains_vertex(6));
}

SECTION("outdegree") { CHECK(graph.outdegree(3) == 0); }
CATCH_SECTION("outdegree") { CATCH_CHECK(graph.outdegree(3) == 0); }
}

TEST_CASE("CSRGraph (unsorted edges)", "[graph]")
CATCH_TEST_CASE("CSRGraph (unsorted edges)", "[graph]")
{
auto edgelist = ww::EdgeList();
edgelist.add_edge(0U, 3U);
Expand All @@ -146,42 +146,42 @@ TEST_CASE("CSRGraph (unsorted edges)", "[graph]")

const auto graph = ww::CSRGraph(edgelist);

SECTION("num_{vertices,edges}")
CATCH_SECTION("num_{vertices,edges}")
{
CHECK(graph.num_vertices() == 4U);
CHECK(graph.num_edges() == 5U);
CATCH_CHECK(graph.num_vertices() == 4U);
CATCH_CHECK(graph.num_edges() == 5U);
}

SECTION("{vertices,edges}")
CATCH_SECTION("{vertices,edges}")
{
using Catch::Matchers::RangeEquals;

const auto vertices = {0U, 1U, 2U, 3U};
CHECK_THAT(graph.vertices(), RangeEquals(vertices));
CATCH_CHECK_THAT(graph.vertices(), RangeEquals(vertices));

const auto edges = {0U, 1U, 2U, 3U, 4U};
CHECK_THAT(graph.edges(), RangeEquals(edges));
CATCH_CHECK_THAT(graph.edges(), RangeEquals(edges));
}
}

TEST_CASE("CSRGraph (parallel edges)", "[graph]")
CATCH_TEST_CASE("CSRGraph (parallel edges)", "[graph]")
{
auto edgelist = ww::EdgeList();
edgelist.add_edge(0U, 1U);
edgelist.add_edge(0U, 1U);

const auto graph = ww::CSRGraph(edgelist);

SECTION("num_{vertices,edges}")
CATCH_SECTION("num_{vertices,edges}")
{
CHECK(graph.num_vertices() == 2U);
CHECK(graph.num_edges() == 2U);
CATCH_CHECK(graph.num_vertices() == 2U);
CATCH_CHECK(graph.num_edges() == 2U);
}

SECTION("outdegree") { CHECK(graph.outdegree(0) == 2U); }
CATCH_SECTION("outdegree") { CATCH_CHECK(graph.outdegree(0U) == 2U); }
}

TEST_CASE("CSRGraph (self loops)", "[graph]")
CATCH_TEST_CASE("CSRGraph (self loops)", "[graph]")
{
auto edgelist = ww::EdgeList();
edgelist.add_edge(1U, 0U);
Expand All @@ -191,19 +191,19 @@ TEST_CASE("CSRGraph (self loops)", "[graph]")

const auto graph = ww::CSRGraph(edgelist);

SECTION("num_{vertices,edges}")
CATCH_SECTION("num_{vertices,edges}")
{
CHECK(graph.num_vertices() == 3U);
CHECK(graph.num_edges() == 4U);
CATCH_CHECK(graph.num_vertices() == 3U);
CATCH_CHECK(graph.num_edges() == 4U);
}

SECTION("contains_vertex")
CATCH_SECTION("contains_vertex")
{
CHECK(graph.contains_vertex(0U));
CHECK(graph.contains_vertex(2U));
CATCH_CHECK(graph.contains_vertex(0U));
CATCH_CHECK(graph.contains_vertex(2U));
}

SECTION("outdegree") { CHECK(graph.outdegree(1U) == 4U); }
CATCH_SECTION("outdegree") { CATCH_CHECK(graph.outdegree(1U) == 4U); }
}

} // namespace
Loading

0 comments on commit d49de3f

Please sign in to comment.